sharedActionSelectorCheck.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_BMV2_COMMON_SHAREDACTIONSELECTORCHECK_H_
#define BACKENDS_BMV2_COMMON_SHAREDACTIONSELECTORCHECK_H_
 
#include <algorithm>
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/coreLibrary.h"
#include "frontends/p4/frontend.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "frontends/p4/typeMap.h"
#include "helpers.h"
#include "ir/ir.h"
#include "lib/error.h"
#include "lib/json.h"
 
namespace P4::BMV2 {
 
using SelectorInput = std::vector<const IR::Expression *>;

template <Standard::Arch arch>
class SharedActionSelectorCheck : public Inspector {
    BMV2::ConversionContext *ctxt;
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
 
    static bool checkSameKeyExpr(const IR::Expression *expr0, const IR::Expression *expr1) {
        if (expr0->node_type_name() != expr1->node_type_name()) return false;
        if (auto pe0 = expr0->to<IR::PathExpression>()) {
            auto pe1 = expr1->to<IR::PathExpression>();
            return pe0->path->name == pe1->path->name && pe0->path->absolute == pe1->path->absolute;
        } else if (auto mem0 = expr0->to<IR::Member>()) {
            auto mem1 = expr1->to<IR::Member>();
            return checkSameKeyExpr(mem0->expr, mem1->expr) && mem0->member == mem1->member;
        } else if (auto l0 = expr0->to<IR::Literal>()) {
            auto l1 = expr1->to<IR::Literal>();
            return *l0 == *l1;
        } else if (auto ai0 = expr0->to<IR::ArrayIndex>()) {
            auto ai1 = expr1->to<IR::ArrayIndex>();
            return checkSameKeyExpr(ai0->left, ai1->left) &&
                   checkSameKeyExpr(ai0->right, ai1->right);
        }
        return false;
    }
 
 public:
    explicit SharedActionSelectorCheck(BMV2::ConversionContext *ctxt) : ctxt(ctxt) {
        refMap = ctxt->refMap;
        typeMap = ctxt->typeMap;
    }
 
    bool preorder(const IR::P4Table *table) override {
        auto implementation = table->properties->getProperty("implementation");
        if (implementation == nullptr) return false;
        if (!implementation->value->is<IR::ExpressionValue>()) {
            ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected expression for property",
                        implementation);
            return false;
        }
        auto propv = implementation->value->to<IR::ExpressionValue>();
        if (!propv->expression->is<IR::PathExpression>()) return false;
        auto pathe = propv->expression->to<IR::PathExpression>();
        auto decl = refMap->getDeclaration(pathe->path, true);
        if (!decl->is<IR::Declaration_Instance>()) {
            ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected a reference to an instance", pathe);
            return false;
        }
        auto dcltype = typeMap->getType(pathe, true);
        if (!dcltype->is<IR::Type_Extern>()) {
            ::P4::error(ErrorType::ERR_UNEXPECTED, "%1%: unexpected type for implementation",
                        dcltype);
            return false;
        }
        auto type_extern_name = dcltype->to<IR::Type_Extern>()->name;
        auto actionSelectorName = Standard::ActionSelectorTraits<arch>::typeName();
        if (type_extern_name != actionSelectorName) return false;
 
        auto key = table->getKey();
        SelectorInput input;
        for (auto ke : key->keyElements) {
            auto mt = refMap->getDeclaration(ke->matchType->path, true)->to<IR::Declaration_ID>();
            BUG_CHECK(mt != nullptr, "%1%: could not find declaration", ke->matchType);
            if (mt->name.name != BMV2::MatchImplementation::selectorMatchTypeName) continue;
            input.push_back(ke->expression);
        }
        auto decl_instance = decl->to<IR::Declaration_Instance>();
        auto it = ctxt->selector_input_map.find(decl_instance);
        if (it == ctxt->selector_input_map.end()) {
            ctxt->selector_input_map[decl_instance] = input;
            return false;
        }
        // returns true if inputs are the same, false otherwise
        auto cmp_inputs = [](const SelectorInput &i1, const SelectorInput &i2) {
            if (i1.size() != i2.size()) return false;
            return std::equal(i1.begin(), i1.end(), i2.begin(), checkSameKeyExpr);
        };
 
        if (!cmp_inputs(it->second, input)) {
            ::P4::error(
                ErrorType::ERR_INVALID,
                "Action selector %1% is used by multiple tables with different selector inputs",
                decl);
        }
 
        return false;
    }
};
 
}  // namespace P4::BMV2
 
#endif /* BACKENDS_BMV2_COMMON_SHAREDACTIONSELECTORCHECK_H_ */