control.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_BMV2_COMMON_CONTROL_H_
#define BACKENDS_BMV2_COMMON_CONTROL_H_
 
#include "controlFlowGraph.h"
#include "expression.h"
#include "extern.h"
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/coreLibrary.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "frontends/p4/typeMap.h"
#include "helpers.h"
#include "ir/ir.h"
#include "lib/algorithm.h"
#include "lib/json.h"
#include "midend/convertEnums.h"
#include "sharedActionSelectorCheck.h"
 
namespace P4::BMV2 {
 
static constexpr unsigned INVALID_ACTION_ID = 0xffffffff;
 
template <Standard::Arch arch>
class ControlConverter : public Inspector {
    ConversionContext *ctxt;
    cstring name;
    P4::P4CoreLibrary &corelib;
 
 protected:
    Util::IJson *convertTable(const CFG::TableNode *node, Util::JsonArray *action_profiles,
                              BMV2::SharedActionSelectorCheck<arch> *selector_check) {
        auto table = node->table;
        LOG3("Processing " << dbp(table));
        auto result = new Util::JsonObject();
        cstring name = table->controlPlaneName();
        result->emplace("name", name);
        result->emplace("id", nextId("tables"_cs));
        result->emplace_non_null("source_info"_cs, table->sourceInfoJsonObj());
        cstring table_match_type = corelib.exactMatch.name;
        auto key = table->getKey();
        auto tkey = mkArrayField(result, "key"_cs);
        ctxt->conv->simpleExpressionsOnly = true;
 
        if (key != nullptr) {
            int count_lpm = 0;
            for (auto ke : key->keyElements) {
                auto expr = ke->expression;
                auto ket = ctxt->typeMap->getType(expr, true);
                if (!ket->is<IR::Type_Bits>() && !ket->is<IR::Type_Boolean>() &&
                    !ket->is<IR::Type_Error>())
                    ::P4::error(ErrorType::ERR_UNSUPPORTED,
                                "%1%: unsupporded key type %2%. "
                                "Supported key types are be bit<> or boolean, or error.",
                                expr, ket);
 
                auto match_type = getKeyMatchType(ke);
                if (match_type == BMV2::MatchImplementation::selectorMatchTypeName) continue;
                // Decreasing order of precedence (bmv2 specification):
                // 0) more than one LPM field is an error
                // 1) if there is at least one RANGE field, then the table is RANGE
                // 2) if there is at least one TERNARY or OPTIONAL field, then the table is TERNARY
                // 3) if there is a LPM field, then the table is LPM
                // 4) otherwise the table is EXACT
                if (match_type == corelib.lpmMatch.name) count_lpm++;
                if (count_lpm > 1)
                    ::P4::error(ErrorType::ERR_UNSUPPORTED,
                                "multiple LPM keys in table %1% not supported", table);
                if (match_type != table_match_type) {
                    if (match_type == BMV2::MatchImplementation::rangeMatchTypeName)
                        table_match_type = BMV2::MatchImplementation::rangeMatchTypeName;
                    if ((match_type == corelib.ternaryMatch.name ||
                         match_type == BMV2::MatchImplementation::optionalMatchTypeName) &&
                        table_match_type != BMV2::MatchImplementation::rangeMatchTypeName)
                        table_match_type = corelib.ternaryMatch.name;
                    if (match_type == corelib.lpmMatch.name &&
                        table_match_type == corelib.exactMatch.name)
                        table_match_type = corelib.lpmMatch.name;
                }
 
                big_int mask;
                if (auto mexp = expr->to<IR::BAnd>()) {
                    if (mexp->right->is<IR::Constant>()) {
                        mask = mexp->right->to<IR::Constant>()->value;
                        expr = mexp->left;
                    } else if (mexp->left->is<IR::Constant>()) {
                        mask = mexp->left->to<IR::Constant>()->value;
                        expr = mexp->right;
                    } else {
                        ::P4::error(ErrorType::ERR_EXPECTED, "%1% must be a constant", expr);
                    }
                } else if (auto slice = expr->to<IR::Slice>()) {
                    expr = slice->e0;
                    int h = slice->getH();
                    int l = slice->getL();
                    mask = Util::maskFromSlice(h, l);
                }
 
                auto keyelement = new Util::JsonObject();
                // Table key fields with match_kind optional will be
                // represented in the BMv2 JSON file the same as a ternary
                // field would be.
                if (match_type == BMV2::MatchImplementation::optionalMatchTypeName) {
                    keyelement->emplace("match_type", corelib.ternaryMatch.name);
                } else {
                    keyelement->emplace("match_type", match_type);
                }
                if (auto na = ke->getAnnotation(IR::Annotation::nameAnnotation)) {
                    BUG_CHECK(na->getExpr().size() == 1, "%1%: expected 1 name", na);
                    auto name = na->getExpr(0)->to<IR::StringLiteral>();
                    BUG_CHECK(name != nullptr, "%1%: expected a string", na);
                    // This is a BMv2 JSON extension: specify a
                    // control-plane name for this key
                    keyelement->emplace("name", name->value);
                }
 
                auto jk = ctxt->conv->convert(expr);
                keyelement->emplace("target", jk->to<Util::JsonObject>()->get("value"));
                if (mask != 0)
                    keyelement->emplace("mask",
                                        stringRepr(mask, ROUNDUP(expr->type->width_bits(), 8)));
                else
                    keyelement->emplace("mask", Util::JsonValue::null);
                tkey->append(keyelement);
            }
        }
        LOG3("table_match_type: " << table_match_type);
        result->emplace("match_type", table_match_type);
        ctxt->conv->simpleExpressionsOnly = false;
 
        auto propertyName = Standard::ActionProfileTraits<arch>::propertyName();
        auto impl = table->properties->getProperty(propertyName);
        bool simple = handleTableImplementation(impl, key, result, action_profiles, selector_check);
 
        unsigned size = 0;
        auto sz = table->properties->getProperty("size");
        if (sz != nullptr) {
            if (sz->value->is<IR::ExpressionValue>()) {
                auto expr = sz->value->to<IR::ExpressionValue>()->expression;
                if (!expr->is<IR::Constant>()) {
                    ::P4::error(ErrorType::ERR_EXPECTED, "%1% must be a constant", sz);
                    size = 0;
                } else {
                    size = expr->to<IR::Constant>()->asInt();
                }
            } else {
                ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected a number", sz);
            }
        }
        if (auto entries = table->getEntries()) {
            size = entries->entries.size();
        }
        if (size == 0) size = BMV2::TableAttributes::defaultTableSize;
 
        result->emplace("max_size", size);
        auto ctrs = table->properties->getProperty("counters");
        if (ctrs != nullptr) {
            // The counters attribute should list the counters of the table, accessed in
            // actions of the table.  We should be checking that this attribute and the
            // actions are consistent?
            if (ctrs->value->is<IR::ExpressionValue>()) {
                auto expr = ctrs->value->to<IR::ExpressionValue>()->expression;
                if (expr->is<IR::ConstructorCallExpression>()) {
                    auto type = ctxt->typeMap->getType(expr, true);
                    if (type == nullptr) return result;
                    if (!type->is<IR::Type_Extern>()) {
                        ::P4::error(ErrorType::ERR_UNEXPECTED,
                                    "%1%: Unexpected type %2% for property. "
                                    "Must be extern.",
                                    ctrs, type);
                        return result;
                    }
                    auto te = type->to<IR::Type_Extern>();
                    if (te->name != "direct_counter" && te->name != "counter") {
                        ::P4::error(ErrorType::ERR_UNEXPECTED,
                                    "%1%: Unexpected type %2% for property. "
                                    "Must be 'counter' or 'direct_counter'.",
                                    ctrs, type);
                        return result;
                    }
                    auto jctr = new Util::JsonObject();
                    cstring ctrname = ctrs->controlPlaneName("counter"_cs);
                    jctr->emplace("name", ctrname);
                    jctr->emplace("id", nextId("counter_arrays"_cs));
                    jctr->emplace_non_null("source_info"_cs, ctrs->sourceInfoJsonObj());
                    // TODO(jafingerhut) - what kind of P4_16 code causes this
                    // code to run, if any?
                    bool direct = te->name == "direct_counter";
                    jctr->emplace("is_direct", direct);
                    jctr->emplace("binding", table->controlPlaneName());
                    ctxt->json->counters->append(jctr);
                } else if (expr->is<IR::PathExpression>()) {
                    auto pe = expr->to<IR::PathExpression>();
                    auto decl = ctxt->refMap->getDeclaration(pe->path, true);
                    if (!decl->is<IR::Declaration_Instance>()) {
                        ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected an instance",
                                    decl->getNode());
                        return result;
                    }
                    cstring ctrname = decl->controlPlaneName();
                    auto it = ctxt->structure->directCounterMap.find(ctrname);
                    LOG3("Looking up " << ctrname);
                    if (it != ctxt->structure->directCounterMap.end()) {
                        ::P4::error(ErrorType::ERR_INVALID,
                                    "%1%: Direct counters cannot be attached to multiple tables"
                                    " %2% and %3%",
                                    decl, it->second, table);
                        return result;
                    }
                    ctxt->structure->directCounterMap.emplace(ctrname, table);
                } else {
                    ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected a counter", ctrs);
                }
            }
            result->emplace("with_counters", true);
        } else {
            result->emplace("with_counters", false);
        }
 
        bool sup_to = false;
        auto timeout = table->properties->getProperty("support_timeout");
        if (timeout != nullptr) {
            if (timeout->value->is<IR::ExpressionValue>()) {
                auto expr = timeout->value->to<IR::ExpressionValue>()->expression;
                if (!expr->is<IR::BoolLiteral>()) {
                    ::P4::error(ErrorType::ERR_EXPECTED, "%1%: must true/false", timeout);
                } else {
                    sup_to = expr->to<IR::BoolLiteral>()->value;
                }
            } else {
                ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected a Boolean", timeout);
            }
        }
        result->emplace("support_timeout", sup_to);
 
        auto dm = table->properties->getProperty("meters");
        if (dm != nullptr) {
            if (dm->value->is<IR::ExpressionValue>()) {
                auto expr = dm->value->to<IR::ExpressionValue>()->expression;
                if (!expr->is<IR::PathExpression>()) {
                    ::P4::error(ErrorType::ERR_EXPECTED,
                                "%1%: expected a reference to a meter declaration", expr);
                } else {
                    auto pe = expr->to<IR::PathExpression>();
                    auto decl = ctxt->refMap->getDeclaration(pe->path, true);
                    auto type = ctxt->typeMap->getType(expr, true);
                    if (type == nullptr) return result;
                    if (type->is<IR::Type_SpecializedCanonical>())
                        type = type->to<IR::Type_SpecializedCanonical>()->baseType;
                    if (!type->is<IR::Type_Extern>()) {
                        ::P4::error(ErrorType::ERR_UNEXPECTED,
                                    "%1%: Unexpected type %2% for property", dm, type);
                        return result;
                    }
                    auto te = type->to<IR::Type_Extern>();
                    if (te->name != "direct_meter") {
                        ::P4::error(ErrorType::ERR_UNEXPECTED,
                                    "%1%: Unexpected type %2% for property", dm, type);
                        return result;
                    }
                    if (!decl->is<IR::Declaration_Instance>()) {
                        ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected an instance",
                                    decl->getNode());
                        return result;
                    }
                    ctxt->structure->directMeterMap.setTable(decl, table);
                    ctxt->structure->directMeterMap.setSize(decl, size);
                    BUG_CHECK(decl->is<IR::Declaration_Instance>(), "%1%: expected an instance",
                              decl->getNode());
                    cstring name = decl->controlPlaneName();
                    result->emplace("direct_meters", name);
                }
            } else {
                ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected a meter", dm);
            }
        } else {
            result->emplace("direct_meters", Util::JsonValue::null);
        }
 
        auto action_ids = mkArrayField(result, "action_ids"_cs);
        auto actions = mkArrayField(result, "actions"_cs);
        auto al = table->getActionList();
 
        std::map<cstring, cstring> useActionName;
        for (auto a : al->actionList) {
            if (a->expression->is<IR::MethodCallExpression>()) {
                auto mce = a->expression->to<IR::MethodCallExpression>();
                if (mce->arguments->size() > 0)
                    ::P4::error(ErrorType::ERR_UNSUPPORTED,
                                "%1%: actions in action list with arguments not supported", a);
            }
            auto decl = ctxt->refMap->getDeclaration(a->getPath(), true);
            BUG_CHECK(decl->is<IR::P4Action>(), "%1%: should be an action name", a);
            auto action = decl->to<IR::P4Action>();
            unsigned id = get(ctxt->structure->ids, action, INVALID_ACTION_ID);
            LOG3("look up id " << action << " " << id);
            BUG_CHECK(id != INVALID_ACTION_ID, "Could not find id for %1%", action);
            action_ids->append(id);
            auto name = action->controlPlaneName();
            actions->append(name);
            useActionName.emplace(action->name, name);
        }
 
        auto next_tables = new Util::JsonObject();
 
        CFG::Node *nextDestination = nullptr;          // if no action is executed
        CFG::Node *defaultLabelDestination = nullptr;  // if the "default" label is executed
        // Note: the "default" label is not the default_action.
        bool hitMiss = false;
        for (auto s : node->successors.edges) {
            if (s->isUnconditional()) {
                nextDestination = s->endpoint;
                LOG3("nextDestination " << s->endpoint);
            } else if (s->isBool()) {
                hitMiss = true;
                LOG3("hitmiss");
            } else if (s->label == "default") {
                defaultLabelDestination = s->endpoint;
                LOG3("default " << s->endpoint);
            }
        }
 
        Util::IJson *nextLabel = nullptr;
        if (!hitMiss) {
            BUG_CHECK(nextDestination, "Could not find default destination for %1%",
                      node->invocation);
            nextLabel = nodeName(nextDestination);
            result->emplace("base_default_next", nextLabel);
            // So if a "default:" switch case exists we set the nextLabel
            // to be the destination of the default: label.
            if (defaultLabelDestination != nullptr) nextLabel = nodeName(defaultLabelDestination);
        } else {
            result->emplace("base_default_next", Util::JsonValue::null);
        }
 
        std::set<cstring> labelsDone;
        for (auto s : node->successors.edges) {
            cstring label;
            if (s->isBool()) {
                label = s->getBool() ? "__HIT__"_cs : "__MISS__"_cs;
            } else if (s->isUnconditional()) {
                continue;
            } else {
                label = s->label;
                if (label == "default") continue;
                label = ::P4::get(useActionName, label);
            }
            next_tables->emplace(label, nodeName(s->endpoint));
            labelsDone.emplace(label);
        }
 
        // Generate labels which don't show up and send them to
        // the nextLabel.
        if (!hitMiss) {
            for (auto a : al->actionList) {
                cstring name = a->getName().name;
                cstring label = ::P4::get(useActionName, name);
                if (labelsDone.find(label) == labelsDone.end())
                    next_tables->emplace(label, nextLabel);
            }
        }
 
        result->emplace("next_tables", next_tables);
        auto defact =
            table->properties->getProperty(IR::TableProperties::defaultActionPropertyName);
        if (defact != nullptr) {
            if (!simple) {
                ::P4::warning(
                    ErrorType::WARN_UNSUPPORTED,
                    "Target does not support default_action for %1% (due to action profiles)",
                    table);
                return result;
            }
 
            if (!defact->value->is<IR::ExpressionValue>()) {
                ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected an action", defact);
                return result;
            }
            auto expr = defact->value->to<IR::ExpressionValue>()->expression;
            const IR::P4Action *action = nullptr;
            const IR::Vector<IR::Argument> *args = nullptr;
 
            if (expr->is<IR::PathExpression>()) {
                auto path = expr->to<IR::PathExpression>()->path;
                auto decl = ctxt->refMap->getDeclaration(path, true);
                BUG_CHECK(decl->is<IR::P4Action>(), "%1%: should be an action name", expr);
                action = decl->to<IR::P4Action>();
            } else if (expr->is<IR::MethodCallExpression>()) {
                auto mce = expr->to<IR::MethodCallExpression>();
                auto mi = P4::MethodInstance::resolve(mce, ctxt->refMap, ctxt->typeMap);
                BUG_CHECK(mi->is<P4::ActionCall>(), "%1%: expected an action", expr);
                action = mi->to<P4::ActionCall>()->action;
                args = mce->arguments;
            } else {
                BUG("%1%: unexpected expression", expr);
            }
 
            unsigned actionid = get(ctxt->structure->ids, action, INVALID_ACTION_ID);
            BUG_CHECK(actionid != INVALID_ACTION_ID, "Could not find id for %1%", action);
            auto entry = new Util::JsonObject();
            entry->emplace("action_id", actionid);
            entry->emplace("action_const", defact->isConstant);
            auto fields = mkArrayField(entry, "action_data"_cs);
            if (args != nullptr) {
                // TODO: use argument names
                for (auto a : *args) {
                    if (a->expression->is<IR::Constant>()) {
                        cstring repr = stringRepr(a->expression->to<IR::Constant>()->value);
                        fields->append(repr);
                    } else {
                        ::P4::error(ErrorType::ERR_EXPECTED,
                                    "%1%: argument must evaluate to a constant integer", a);
                        return result;
                    }
                }
            }
            entry->emplace("action_entry_const", defact->isConstant);
            result->emplace("default_entry", entry);
        }
        convertTableEntries(table, result);
        return result;
    }
    void convertTableEntries(const IR::P4Table *table, Util::JsonObject *jsonTable) {
        auto entriesList = table->getEntries();
        if (entriesList == nullptr) return;
 
        auto entries = mkArrayField(jsonTable, "entries"_cs);
        int entryPriority = 1;  // default priority is defined by index position
        for (auto e : entriesList->entries) {
            auto entry = new Util::JsonObject();
            entry->emplace_non_null("source_info"_cs, e->sourceInfoJsonObj());
 
            auto keyset = e->getKeys();
            auto matchKeys = mkArrayField(entry, "match_key"_cs);
            int keyIndex = 0;
            for (auto k : keyset->components) {
                auto key = new Util::JsonObject();
                auto tableKey = table->getKey()->keyElements.at(keyIndex);
                int keyWidth = 0;
                if (tableKey->expression->type->is<IR::Type_Error>()) {
                    // error type doesn't have a width, and will fail below, checking the key
                    // expression k, so it doesn't matter what keyWidth is.
                } else {
                    keyWidth = tableKey->expression->type->width_bits();
                }
                auto k8 = ROUNDUP(keyWidth, 8);
                auto matchType = getKeyMatchType(tableKey);
                // Table key fields with match_kind optional will be
                // represented in the BMv2 JSON file the same as a ternary
                // field would be.
                if (matchType == "optional") {
                    key->emplace("match_type", "ternary");
                } else {
                    key->emplace("match_type", matchType);
                }
                if (matchType == corelib.exactMatch.name) {
                    if (k->is<IR::Constant>())
                        key->emplace("key", stringRepr(k->to<IR::Constant>()->value, k8));
                    else if (k->is<IR::BoolLiteral>())
                        // booleans are converted to ints
                        key->emplace("key",
                                     stringRepr(k->to<IR::BoolLiteral>()->value ? 1 : 0, k8));
                    else
                        ::P4::error(ErrorType::ERR_UNSUPPORTED,
                                    "%1%: unsupported exact key expression", k);
                } else if (matchType == corelib.ternaryMatch.name) {
                    if (k->is<IR::Mask>()) {
                        auto km = k->to<IR::Mask>();
                        key->emplace("key", stringRepr(km->left->to<IR::Constant>()->value, k8));
                        key->emplace("mask", stringRepr(km->right->to<IR::Constant>()->value, k8));
                    } else if (k->is<IR::Constant>()) {
                        key->emplace("key", stringRepr(k->to<IR::Constant>()->value, k8));
                        key->emplace("mask", stringRepr(Util::mask(keyWidth), k8));
                    } else if (k->is<IR::BoolLiteral>()) {
                        key->emplace("key",
                                     stringRepr(k->to<IR::BoolLiteral>()->value ? 1 : 0, k8));
                        key->emplace("mask", stringRepr(Util::mask(keyWidth), k8));
                    } else if (k->is<IR::DefaultExpression>()) {
                        key->emplace("key", stringRepr(0, k8));
                        key->emplace("mask", stringRepr(0, k8));
                    } else {
                        ::P4::error(ErrorType::ERR_UNSUPPORTED,
                                    "%1%: unsupported ternary key expression", k);
                    }
                } else if (matchType == corelib.lpmMatch.name) {
                    if (k->is<IR::Mask>()) {
                        auto km = k->to<IR::Mask>();
                        key->emplace("key", stringRepr(km->left->to<IR::Constant>()->value, k8));
                        auto trailing_zeros = [](unsigned long n, unsigned long keyWidth) {
                            return n ? __builtin_ctzl(n) : static_cast<int>(keyWidth);
                        };
                        auto count_ones = [](unsigned long n) {
                            return n ? __builtin_popcountl(n) : 0;
                        };
                        auto mask =
                            static_cast<unsigned long>(km->right->to<IR::Constant>()->value);
                        auto len = trailing_zeros(mask, keyWidth);
                        if (len + count_ones(mask) != keyWidth)  // any remaining 0s in the prefix?
                            ::P4::error(ErrorType::ERR_INVALID, "%1%: invalid mask for LPM key", k);
                        else
                            key->emplace("prefix_length", keyWidth - len);
                    } else if (k->is<IR::Constant>()) {
                        key->emplace("key", stringRepr(k->to<IR::Constant>()->value, k8));
                        key->emplace("prefix_length", keyWidth);
                    } else if (k->is<IR::DefaultExpression>()) {
                        key->emplace("key", stringRepr(0, k8));
                        key->emplace("prefix_length", 0);
                    } else {
                        ::P4::error(ErrorType::ERR_UNSUPPORTED,
                                    "%1%: unsupported LPM key expression", k);
                    }
                } else if (matchType == "range") {
                    if (k->is<IR::Range>()) {
                        auto kr = k->to<IR::Range>();
                        key->emplace("start", stringRepr(kr->left->to<IR::Constant>()->value, k8));
                        key->emplace("end", stringRepr(kr->right->to<IR::Constant>()->value, k8));
                    } else if (k->is<IR::Constant>()) {
                        key->emplace("start", stringRepr(k->to<IR::Constant>()->value, k8));
                        key->emplace("end", stringRepr(k->to<IR::Constant>()->value, k8));
                    } else if (k->is<IR::DefaultExpression>()) {
                        key->emplace("start", stringRepr(0, k8));
                        key->emplace("end", stringRepr((1 << keyWidth) - 1, k8));  // 2^N -1
                    } else {
                        ::P4::error(ErrorType::ERR_UNSUPPORTED,
                                    "%1% unsupported range key expression", k);
                    }
                } else if (matchType == "optional") {
                    // Table key fields with match_kind optional with
                    // "const entries" in the P4 source code will be
                    // represented using the same "key" and "mask" keys in
                    // the BMv2 JSON file as table key fields with
                    // match_kind ternary.  In the P4 source code we only
                    // allow exact values or a DefaultExpression (_ or
                    // default), no &&& expression.
                    if (k->is<IR::Constant>()) {
                        key->emplace("key", stringRepr(k->to<IR::Constant>()->value, k8));
                        key->emplace("mask", stringRepr(Util::mask(keyWidth), k8));
                    } else if (k->is<IR::DefaultExpression>()) {
                        key->emplace("key", stringRepr(0, k8));
                        key->emplace("mask", stringRepr(0, k8));
                    } else {
                        ::P4::error(ErrorType::ERR_UNSUPPORTED,
                                    "%1%: unsupported optional key expression", k);
                    }
                } else {
                    ::P4::error(ErrorType::ERR_UNKNOWN, "unknown key match type '%2%' for key %1%",
                                k, matchType);
                }
                matchKeys->append(key);
                keyIndex++;
            }
 
            auto action = new Util::JsonObject();
            auto actionRef = e->getAction();
            if (!actionRef->is<IR::MethodCallExpression>())
                ::P4::error(ErrorType::ERR_INVALID, "Invalid action '%1%' in entries list.",
                            actionRef);
            auto actionCall = actionRef->to<IR::MethodCallExpression>();
            auto method = actionCall->method->to<IR::PathExpression>()->path;
            auto decl = ctxt->refMap->getDeclaration(method, true);
            auto actionDecl = decl->to<IR::P4Action>();
            unsigned id = get(ctxt->structure->ids, actionDecl, INVALID_ACTION_ID);
            BUG_CHECK(id != INVALID_ACTION_ID, "Could not find id for %1%", actionDecl);
            action->emplace("action_id", id);
            auto actionData = mkArrayField(action, "action_data"_cs);
            for (auto arg : *actionCall->arguments) {
                actionData->append(stringRepr(arg->expression->to<IR::Constant>()->value, 0));
            }
            entry->emplace("action_entry", action);
 
            if (auto priorityAnnotation = e->getAnnotation("priority"_cs)) {
                const auto &expr = priorityAnnotation->getExpr();
                if (expr.size() > 1)
                    ::P4::error(ErrorType::ERR_INVALID, "Invalid priority value %1%", expr);
                auto priValue = expr.front();
                if (!priValue->is<IR::Constant>())
                    ::P4::error(ErrorType::ERR_INVALID,
                                "Invalid priority value %1%; must be constant.", expr);
                entry->emplace("priority", priValue->to<IR::Constant>()->value);
            } else {
                entry->emplace("priority", entryPriority);
            }
            entryPriority += 1;
 
            entries->append(entry);
        }
    }
    cstring getKeyMatchType(const IR::KeyElement *ke) {
        auto path = ke->matchType->path;
        auto mt = ctxt->refMap->getDeclaration(path, true)->to<IR::Declaration_ID>();
        BUG_CHECK(mt != nullptr, "%1%: could not find declaration", ke->matchType);
 
        if (mt->name.name == corelib.exactMatch.name ||
            mt->name.name == corelib.ternaryMatch.name || mt->name.name == corelib.lpmMatch.name ||
            ctxt->structure->match_kinds.count(mt->name.name)) {
            return mt->name.name;
        }
 
        ::P4::error(ErrorType::ERR_UNSUPPORTED, "%1%: match type not supported on this target", mt);
        return "invalid"_cs;
    }
    bool handleTableImplementation(const IR::Property *implementation, const IR::Key *key,
                                   Util::JsonObject *table, Util::JsonArray *action_profiles,
                                   BMV2::SharedActionSelectorCheck<arch> *) {
        if (implementation == nullptr) {
            table->emplace("type", "simple");
            return true;
        }
 
        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>();
 
        bool isSimpleTable = true;
        Util::JsonObject *action_profile;
        cstring apname;
 
        if (propv->expression->is<IR::ConstructorCallExpression>()) {
            auto cc =
                P4::ConstructorCall::resolve(propv->expression->to<IR::ConstructorCallExpression>(),
                                             ctxt->refMap, ctxt->typeMap);
            if (!cc->is<P4::ExternConstructorCall>()) {
                ::P4::error(ErrorType::ERR_EXPECTED, "%1%: expected extern object for property",
                            implementation);
                return false;
            }
            auto ecc = cc->to<P4::ExternConstructorCall>();
            auto implementationType = ecc->type;
            auto arguments = ecc->cce->arguments;
            apname = implementation->controlPlaneName(ctxt->refMap->newName("action_profile"));
            action_profile = new Util::JsonObject();
            action_profiles->append(action_profile);
            action_profile->emplace("name", apname);
            action_profile->emplace("id", nextId("action_profiles"_cs));
            action_profile->emplace_non_null("source_info"_cs,
                                             propv->expression->sourceInfoJsonObj());
            // TODO(jafingerhut) - add line/col here?
            // TBD what about the else if cases below?
 
            auto add_size = [&action_profile, &arguments](size_t arg_index) {
                auto size_expr = arguments->at(arg_index)->expression;
                int size;
                if (!size_expr->is<IR::Constant>()) {
                    ::P4::error(ErrorType::ERR_EXPECTED, "%1% must be a constant", size_expr);
                    size = 0;
                } else {
                    size = size_expr->to<IR::Constant>()->asInt();
                }
                action_profile->emplace("max_size", size);
            };
 
            auto actionSelectorName = Standard::ActionSelectorTraits<arch>::typeName();
            if (implementationType->name == actionSelectorName) {
                BUG_CHECK(arguments->size() == 3, "%1%: expected 3 arguments", arguments);
                isSimpleTable = false;
                auto selector = new Util::JsonObject();
                table->emplace("type", "indirect_ws");
                action_profile->emplace("selector"_cs, selector);
                add_size(1);
                auto hash = arguments->at(0)->expression;
                auto ei = P4::EnumInstance::resolve(hash, ctxt->typeMap);
                if (ei == nullptr) {
                    ::P4::error(ErrorType::ERR_EXPECTED,
                                "%1%: hash must be a constant on this target", hash);
                } else {
                    cstring algo = ei->name;
                    selector->emplace("algo", algo);
                }
                auto input = mkArrayField(selector, "input"_cs);
                for (auto ke : key->keyElements) {
                    auto mt = ctxt->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;
 
                    auto expr = ke->expression;
                    auto jk = ctxt->conv->convert(expr);
                    input->append(jk);
                }
            } else if (implementationType->name ==
                       Standard::ActionProfileTraits<arch>::typeName()) {
                isSimpleTable = false;
                table->emplace("type", "indirect");
                add_size(0);
            } else {
                ::P4::error(ErrorType::ERR_UNEXPECTED, "%1%: expected value for property", propv);
            }
        } else if (propv->expression->is<IR::PathExpression>()) {
            auto pathe = propv->expression->to<IR::PathExpression>();
            auto decl = ctxt->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;
            }
            apname = decl->controlPlaneName();
            auto dcltype = ctxt->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 actionProfileName = Standard::ActionProfileTraits<arch>::typeName();
            auto actionSelectorName = Standard::ActionSelectorTraits<arch>::typeName();
            if (type_extern_name == actionProfileName) {
                table->emplace("type", "indirect");
            } else if (type_extern_name == actionSelectorName) {
                table->emplace("type", "indirect_ws");
            } else {
                ::P4::error(ErrorType::ERR_UNEXPECTED, "%1%: unexpected type for implementation",
                            dcltype);
                return false;
            }
            isSimpleTable = false;
            if (ctxt->toplevel->hasValue(decl->getNode())) {
                auto eb = ctxt->toplevel->getValue(decl->getNode());
                BUG_CHECK(eb->is<IR::ExternBlock>(), "Not an extern block?");
                ExternConverter::cvtExternInstance(ctxt, decl->to<IR::Declaration>(),
                                                   eb->to<IR::ExternBlock>(), emitExterns);
            }
        } else {
            ::P4::error(ErrorType::ERR_UNEXPECTED, "%1%: unexpected value for property", propv);
            return false;
        }
        table->emplace("action_profile", apname);
        return isSimpleTable;
    }
 
    Util::IJson *convertIf(const CFG::IfNode *node, cstring prefix) {
        (void)prefix;
        auto result = new Util::JsonObject();
        result->emplace("name", node->name);
        result->emplace("id", nextId("conditionals"_cs));
        result->emplace_non_null("source_info"_cs, node->statement->condition->sourceInfoJsonObj());
        auto j = ctxt->conv->convert(node->statement->condition, true, false);
        CHECK_NULL(j);
        result->emplace("expression"_cs, j);
        for (auto e : node->successors.edges) {
            Util::IJson *dest = nodeName(e->endpoint);
            cstring label = Util::toString(e->getBool());
            label += "_next";
            result->emplace(label, dest);
        }
        return result;
    }
 
 public:
    const bool emitExterns;
    bool preorder(const IR::P4Control *cont) override {
        auto result = new Util::JsonObject();
 
        result->emplace("name", name);
        result->emplace("id", nextId("control"_cs));
        result->emplace_non_null("source_info"_cs, cont->sourceInfoJsonObj());
 
        auto cfg = new CFG();
        cfg->build(cont, ctxt->refMap, ctxt->typeMap);
        bool success = cfg->checkImplementable();
        if (!success) return false;
 
        if (cfg->entryPoint->successors.size() == 0) {
            result->emplace("init_table", Util::JsonValue::null);
        } else {
            BUG_CHECK(cfg->entryPoint->successors.size() == 1, "Expected 1 start node for %1%",
                      cont);
            auto start = (*(cfg->entryPoint->successors.edges.begin()))->endpoint;
            result->emplace("init_table", nodeName(start));
        }
 
        auto tables = mkArrayField(result, "tables"_cs);
        auto action_profiles = mkArrayField(result, "action_profiles"_cs);
        auto conditionals = mkArrayField(result, "conditionals"_cs);
        ctxt->action_profiles = action_profiles;
 
        auto selector_check = new BMV2::SharedActionSelectorCheck<arch>(ctxt);
        cont->apply(*selector_check);
 
        std::set<const IR::P4Table *> done;
 
        // Tables are created prior to the other local declarations
        for (auto node : cfg->allNodes) {
            auto tn = node->to<CFG::TableNode>();
            if (tn != nullptr) {
                if (done.find(tn->table) != done.end())
                    // The same table may appear in multiple nodes in the CFG.
                    // We emit it only once.  Other checks should ensure that
                    // the CFG is implementable.
                    continue;
                done.emplace(tn->table);
                auto j = convertTable(tn, action_profiles, selector_check);
                if (::P4::errorCount() > 0) return false;
                tables->append(j);
            } else if (node->is<CFG::IfNode>()) {
                auto j = convertIf(node->to<CFG::IfNode>(), cont->name);
                if (::P4::errorCount() > 0) return false;
                conditionals->append(j);
            }
        }
 
        for (auto c : cont->controlLocals) {
            if (c->is<IR::Declaration_Constant>() || c->is<IR::Declaration_Variable>() ||
                c->is<IR::P4Action>() || c->is<IR::P4Table>())
                continue;
            if (c->is<IR::Declaration_Instance>()) {
                auto bl = ctxt->structure->resourceMap.at(c);
                CHECK_NULL(bl);
                if (bl->is<IR::ControlBlock>() || bl->is<IR::ParserBlock>())
                    // Since this block has not been inlined, it is probably unused
                    // So we don't do anything.
                    continue;
                if (bl->is<IR::ExternBlock>()) {
                    auto eb = bl->to<IR::ExternBlock>();
                    ExternConverter::cvtExternInstance(ctxt, c, eb, emitExterns);
                    continue;
                }
            }
            P4C_UNIMPLEMENTED("%1%: not yet handled", c);
        }
 
        ctxt->json->pipelines->append(result);
        return false;
    }
 
    explicit ControlConverter(ConversionContext *ctxt, cstring name, const bool &emitExterns_)
        : ctxt(ctxt),
          name(name),
          corelib(P4::P4CoreLibrary::instance()),
          emitExterns(emitExterns_) {
        setName("ControlConverter");
    }
};
 
}  // namespace P4::BMV2
 
#endif /* BACKENDS_BMV2_COMMON_CONTROL_H_ */