bmv2/common/helpers.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_BMV2_COMMON_HELPERS_H_
#define BACKENDS_BMV2_COMMON_HELPERS_H_
 
#include "JsonObjects.h"
#include "backends/common/programStructure.h"
#include "controlFlowGraph.h"
#include "expression.h"
#include "frontends/common/model.h"
#include "frontends/p4-14/fromv1.0/v1model.h"
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/json.h"
#include "lib/ordered_map.h"
 
namespace P4::BMV2 {
 
using namespace P4::literals;
 
#ifndef UNUSED
#define UNUSED __attribute__((__unused__))
#endif
 
class MatchImplementation {
 public:
    static const cstring selectorMatchTypeName;
    static const cstring rangeMatchTypeName;
    static const cstring optionalMatchTypeName;
};
 
class TableAttributes {
 public:
    static const unsigned defaultTableSize;
};
 
class V1ModelProperties {
 public:
    static const cstring jsonMetadataParameterName;

    static const cstring validField;
};
 
// V1Model-specific blocks.
enum class BlockConverted {
    None,
    Parser,
    Ingress,
    Egress,
    Deparser,
    ChecksumCompute,
    ChecksumVerify
};
 
namespace Standard {

enum class Arch { V1MODEL, PSA, PNA, V1MODEL2020 };

template <Arch arch>
struct ActionProfileTraits;
 
template <>
struct ActionProfileTraits<Arch::V1MODEL> {
    static const cstring name() { return "action profile"_cs; }
    static const cstring propertyName() {
        return P4V1::V1Model::instance.tableAttributes.tableImplementation.name;
    }
    static const cstring typeName() { return P4V1::V1Model::instance.action_profile.name; }
    static const cstring sizeParamName() { return "size"_cs; }
};
 
template <>
struct ActionProfileTraits<Arch::V1MODEL2020> : public ActionProfileTraits<Arch::V1MODEL> {};
 
template <>
struct ActionProfileTraits<Arch::PSA> {
    static const cstring name() { return "action profile"_cs; }
    static const cstring propertyName() { return "implementation"_cs; }
    static const cstring typeName() { return "ActionProfile"_cs; }
    static const cstring sizeParamName() { return "size"_cs; }
};
 
template <>
struct ActionProfileTraits<Arch::PNA> : public ActionProfileTraits<Arch::PSA> {};

template <Arch arch>
struct ActionSelectorTraits;
 
template <>
struct ActionSelectorTraits<Arch::V1MODEL> : public ActionProfileTraits<Arch::V1MODEL> {
    static const cstring name() { return "action selector"_cs; }
    static const cstring typeName() { return P4V1::V1Model::instance.action_selector.name; }
};
 
template <>
struct ActionSelectorTraits<Arch::V1MODEL2020> : public ActionProfileTraits<Arch::V1MODEL2020> {};
 
template <>
struct ActionSelectorTraits<Arch::PSA> : public ActionProfileTraits<Arch::PSA> {
    static const cstring name() { return "action selector"_cs; }
    static const cstring typeName() { return "ActionSelector"_cs; }
};
 
template <>
struct ActionSelectorTraits<Arch::PNA> : public ActionSelectorTraits<Arch::PSA> {};

template <Arch arch>
struct RegisterTraits;
 
template <>
struct RegisterTraits<Arch::V1MODEL> {
    static const cstring name() { return "register"_cs; }
    static const cstring typeName() { return P4V1::V1Model::instance.registers.name; }
    static const cstring sizeParamName() { return "size"_cs; }
    static size_t dataTypeParamIdx() { return 0; }
    static std::optional<size_t> indexTypeParamIdx() { return std::nullopt; }
};
 
template <>
struct RegisterTraits<Arch::V1MODEL2020> : public RegisterTraits<Arch::V1MODEL> {
    static std::optional<size_t> indexTypeParamIdx() { return 1; }
};
 
template <>
struct RegisterTraits<Arch::PSA> {
    static const cstring name() { return "register"_cs; }
    static const cstring typeName() { return "Register"_cs; }
    static const cstring sizeParamName() { return "size"_cs; }
    static size_t dataTypeParamIdx() { return 0; }
    static std::optional<size_t> indexTypeParamIdx() { return 1; }
};
 
template <>
struct RegisterTraits<Arch::PNA> : public RegisterTraits<Arch::PSA> {};
 
template <Arch arch>
struct CounterExtern {};
template <Arch arch>
struct MeterExtern {};
 
}  // namespace Standard
 
namespace Helpers {
 
template <typename Kind>
struct CounterlikeTraits;


template <>
struct CounterlikeTraits<Standard::CounterExtern<Standard::Arch::V1MODEL>> {
    static const cstring name() { return "counter"_cs; }
    static const cstring directPropertyName() {
        return P4V1::V1Model::instance.tableAttributes.counters.name;
    }
    static const cstring typeName() { return P4V1::V1Model::instance.counter.name; }
    static const cstring directTypeName() { return P4V1::V1Model::instance.directCounter.name; }
    static const cstring sizeParamName() { return "size"_cs; }
    static std::optional<size_t> indexTypeParamIdx() { return std::nullopt; }
};
 
template <>
struct CounterlikeTraits<Standard::CounterExtern<Standard::Arch::V1MODEL2020>> {
    static const cstring name() { return "counter"_cs; }
    static const cstring directPropertyName() {
        return P4V1::V1Model::instance.tableAttributes.counters.name;
    }
    static const cstring typeName() { return P4V1::V1Model::instance.counter.name; }
    static const cstring directTypeName() { return P4V1::V1Model::instance.directCounter.name; }
    static const cstring sizeParamName() { return "size"_cs; }
    static std::optional<size_t> indexTypeParamIdx() { return 0; }
};

template <>
struct CounterlikeTraits<Standard::CounterExtern<Standard::Arch::PSA>> {
    static const cstring name() { return "counter"_cs; }
    static const cstring directPropertyName() { return "psa_direct_counter"_cs; }
    static const cstring typeName() { return "Counter"_cs; }
    static const cstring directTypeName() { return "DirectCounter"_cs; }
    static const cstring sizeParamName() { return "n_counters"_cs; }
    static std::optional<size_t> indexTypeParamIdx() { return 1; }
};

template <>
struct CounterlikeTraits<Standard::CounterExtern<Standard::Arch::PNA>>
    : public CounterlikeTraits<Standard::CounterExtern<Standard::Arch::PSA>> {
    static const cstring directPropertyName() { return "pna_direct_counter"_cs; }
};

template <>
struct CounterlikeTraits<Standard::MeterExtern<Standard::Arch::V1MODEL>> {
    static const cstring name() { return "meter"_cs; }
    static const cstring directPropertyName() {
        return P4V1::V1Model::instance.tableAttributes.meters.name;
    }
    static const cstring typeName() { return P4V1::V1Model::instance.meter.name; }
    static const cstring directTypeName() { return P4V1::V1Model::instance.directMeter.name; }
    static const cstring sizeParamName() { return "size"_cs; }
    static std::optional<size_t> indexTypeParamIdx() { return std::nullopt; }
};
 
template <>
struct CounterlikeTraits<Standard::MeterExtern<Standard::Arch::V1MODEL2020>> {
    static const cstring name() { return "meter"_cs; }
    static const cstring directPropertyName() {
        return P4V1::V1Model::instance.tableAttributes.meters.name;
    }
    static const cstring typeName() { return P4V1::V1Model::instance.meter.name; }
    static const cstring directTypeName() { return P4V1::V1Model::instance.directMeter.name; }
    static const cstring sizeParamName() { return "size"_cs; }
    static std::optional<size_t> indexTypeParamIdx() { return 0; }
};

template <>
struct CounterlikeTraits<Standard::MeterExtern<Standard::Arch::PSA>> {
    static const cstring name() { return "meter"_cs; }
    static const cstring directPropertyName() { return "psa_direct_meter"_cs; }
    static const cstring typeName() { return "Meter"_cs; }
    static const cstring directTypeName() { return "DirectMeter"_cs; }
    static const cstring sizeParamName() { return "n_meters"_cs; }
    static std::optional<size_t> indexTypeParamIdx() { return 0; }
};

template <>
struct CounterlikeTraits<Standard::MeterExtern<Standard::Arch::PNA>>
    : public CounterlikeTraits<Standard::MeterExtern<Standard::Arch::PSA>> {
    static const cstring directPropertyName() { return "pna_direct_meter"_cs; }
};
 
}  // namespace Helpers
 
using BlockTypeMap = std::map<const IR::Block *, const IR::Type *>;

using SelectorInput = std::vector<const IR::Expression *>;
 
struct ConversionContext {
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    const IR::ToplevelBlock *toplevel;
    BlockConverted blockConverted;
    P4::ProgramStructure *structure;
    ExpressionConverter *conv;
    BMV2::JsonObjects *json;

    Util::JsonArray *action_profiles = nullptr;
 
    std::map<const IR::Declaration_Instance *, SelectorInput> selector_input_map;
 
    const SelectorInput *get_selector_input(const IR::Declaration_Instance *selector) {
        auto it = selector_input_map.find(selector);
        if (it == selector_input_map.end()) return nullptr;  // selector never used
        return &it->second;
    }
 
    ConversionContext(P4::ReferenceMap *refMap, P4::TypeMap *typeMap,
                      const IR::ToplevelBlock *toplevel, P4::ProgramStructure *structure,
                      ExpressionConverter *conv, JsonObjects *json)
        : refMap(refMap),
          typeMap(typeMap),
          toplevel(toplevel),
          blockConverted(BlockConverted::None),
          structure(structure),
          conv(conv),
          json(json) {}
 
    void addToFieldList(const IR::Expression *expr, Util::JsonArray *fl);
    int createFieldList(const IR::Expression *expr, cstring listName, bool learn = false);
    cstring createCalculation(cstring algo, const IR::Expression *fields,
                              Util::JsonArray *calculations, bool usePayload, const IR::Node *node);
    static void modelError(const char *format, const IR::Node *place);
};
 
Util::IJson *nodeName(const CFG::Node *node);
Util::JsonArray *mkArrayField(Util::JsonObject *parent, cstring name);
Util::JsonArray *mkParameters(Util::JsonObject *object);
Util::JsonObject *mkPrimitive(cstring name, Util::JsonArray *appendTo);
Util::JsonObject *mkPrimitive(cstring name);
cstring stringRepr(big_int value, unsigned bytes = 0);
unsigned nextId(cstring group);
const IR::ListExpression *convertToList(const IR::Expression *expr, P4::TypeMap *typeMap);
 
}  // namespace P4::BMV2
 
#endif /* BACKENDS_BMV2_COMMON_HELPERS_H_ */