checkExternInvocationCommon.h

/*
 * Copyright 2021 Intel Corp.
 * SPDX-FileCopyrightText: 2021 Intel Corp.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef MIDEND_CHECKEXTERNINVOCATIONCOMMON_H_
#define MIDEND_CHECKEXTERNINVOCATIONCOMMON_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/methodInstance.h"
#include "ir/ir.h"
#include "ir/visitor.h"
#include "lib/bitvec.h"
 
namespace P4 {
 
class TypeMap;

class CheckExternInvocationCommon : public Inspector, public ResolutionContext {
 protected:
    TypeMap *typeMap;
    std::map<cstring /* extType */, bitvec> pipeConstraints;

    virtual void initPipeConstraints() = 0;

    virtual cstring getBlockName(int bit) = 0;

    virtual void checkExtern(const ExternMethod *extMethod, const IR::MethodCallExpression *expr) {
        (void)extMethod;
        (void)expr;
    }

    virtual void checkExtern(const ExternFunction *extFunction,
                             const IR::MethodCallExpression *expr) {
        (void)extFunction;
        (void)expr;
    }

    cstring extractBlock(bitvec vec) {
        int bit = vec.ffs(0);
        BUG_CHECK(vec.ffs(bit), "Trying to extract multiple block encodings");
        return getBlockName(bit);
    }

    void setPipeConstraints(cstring extType, bitvec vec) {
        if (!pipeConstraints.count(extType)) {
            pipeConstraints.emplace(extType, vec);
        } else {
            auto &cons = pipeConstraints.at(extType);
            cons |= vec;
        }
    }

    void checkPipeConstraints(cstring extType, bitvec bv, const IR::MethodCallExpression *expr,
                              cstring extName, cstring pipe) {
        BUG_CHECK(pipeConstraints.count(extType), "pipe constraints not defined for %1%", extType);
        auto constraint = pipeConstraints.at(extType) & bv;
        if (!bv.empty() && constraint.empty()) {
            if (extName != "")
                ::P4::error(ErrorType::ERR_UNSUPPORTED, "%s %s %s cannot be used in the %s %s",
                            expr->srcInfo, extType, extName, pipe, extractBlock(bv));
            else
                ::P4::error(ErrorType::ERR_UNSUPPORTED, "%s %s cannot be used in the %s %s",
                            expr->srcInfo, extType, pipe, extractBlock(bv));
        }
    }
 
    explicit CheckExternInvocationCommon(TypeMap *typeMap) : typeMap(typeMap) {}
 
 public:
    bool preorder(const IR::MethodCallExpression *expr) override {
        auto mi = MethodInstance::resolve(expr, this, typeMap);
        if (auto extMethod = mi->to<ExternMethod>()) {
            checkExtern(extMethod, expr);
        } else if (auto extFunction = mi->to<ExternFunction>()) {
            checkExtern(extFunction, expr);
        }
        return false;
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_CHECKEXTERNINVOCATIONCOMMON_H_ */