checkExternInvocationCommon.h

/*
Copyright 2021 Intel Corp.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#ifndef MIDEND_CHECKEXTERNINVOCATIONCOMMON_H_
#define MIDEND_CHECKEXTERNINVOCATIONCOMMON_H_
 
#include "frontends/p4/methodInstance.h"
#include "ir/ir.h"
#include "ir/visitor.h"
#include "lib/bitvec.h"
 
namespace P4 {
 
class ReferenceMap;
class TypeMap;

class CheckExternInvocationCommon : public Inspector {
 protected:
    ReferenceMap *refMap;
    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));
        }
    }
 
    CheckExternInvocationCommon(ReferenceMap *refMap, TypeMap *typeMap)
        : refMap(refMap), typeMap(typeMap) {}
 
 public:
    bool preorder(const IR::MethodCallExpression *expr) override {
        auto mi = MethodInstance::resolve(expr, refMap, 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_ */