helpers.h

/*
Copyright 2013-present Barefoot Networks, Inc.
 
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 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/fromv1.0/v1model.h"
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/json.h"
#include "lib/ordered_map.h"
 
namespace 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, 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 <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 <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 <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::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; }
};
 
}  // 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 BMV2
 
#endif /* BACKENDS_BMV2_COMMON_HELPERS_H_ */