p4RuntimeArchHandler.h

/*
Copyright 2018-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 CONTROL_PLANE_P4RUNTIMEARCHHANDLER_H_
#define CONTROL_PLANE_P4RUNTIMEARCHHANDLER_H_
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wpedantic"
#include <google/protobuf/util/json_util.h>
#pragma GCC diagnostic pop
 
#include <optional>
#include <set>
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wpedantic"
#include "p4/config/v1/p4info.pb.h"
#include "p4/v1/p4runtime.pb.h"
#pragma GCC diagnostic pop
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/externInstance.h"
#include "frontends/p4/methodInstance.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/ordered_set.h"
#include "typeSpecConverter.h"
 
namespace P4 {
 
using namespace literals;
 
namespace ControlPlaneAPI {
 
using p4rt_id_t = uint32_t;
 
class P4RuntimeSymbolType {
 public:
    virtual ~P4RuntimeSymbolType() {}
 
    explicit operator p4rt_id_t() const { return id; }
 
    static P4RuntimeSymbolType P4RT_ACTION() {
        return P4RuntimeSymbolType(::p4::config::v1::P4Ids::ACTION);
    }
    static P4RuntimeSymbolType P4RT_TABLE() {
        return P4RuntimeSymbolType(::p4::config::v1::P4Ids::TABLE);
    }
    static P4RuntimeSymbolType P4RT_VALUE_SET() {
        return P4RuntimeSymbolType(::p4::config::v1::P4Ids::VALUE_SET);
    }
    static P4RuntimeSymbolType P4RT_CONTROLLER_HEADER() {
        return P4RuntimeSymbolType(::p4::config::v1::P4Ids::CONTROLLER_HEADER);
    }
 
    static P4RuntimeSymbolType P4RT_OTHER_EXTERNS_START() {
        return P4RuntimeSymbolType(::p4::config::v1::P4Ids::OTHER_EXTERNS_START);
    }
 
    bool operator==(const P4RuntimeSymbolType &other) const { return id == other.id; }
 
    bool operator!=(const P4RuntimeSymbolType &other) const { return !(*this == other); }
 
    bool operator<(const P4RuntimeSymbolType &other) const { return id < other.id; }
 
 protected:
    static P4RuntimeSymbolType make(p4rt_id_t id) { return P4RuntimeSymbolType(id); }
 
 private:
    // even if the constructor is protected, the static functions in the derived
    // classes cannot access it, which is why we use the make factory function
    explicit constexpr P4RuntimeSymbolType(p4rt_id_t id) noexcept : id(id) {}
 
    p4rt_id_t id;
};
 
class P4RuntimeSymbolTableIface {
 public:
    virtual ~P4RuntimeSymbolTableIface() {}
    virtual void add(P4RuntimeSymbolType type, const IR::IDeclaration *declaration) = 0;
    virtual void add(P4RuntimeSymbolType type, cstring name,
                     std::optional<p4rt_id_t> id = std::nullopt) = 0;
    virtual p4rt_id_t getId(P4RuntimeSymbolType type,
                            const IR::IDeclaration *declaration) const = 0;
    virtual p4rt_id_t getId(P4RuntimeSymbolType type, cstring name) const = 0;
    virtual cstring getAlias(cstring name) const = 0;
};
 
class P4RuntimeArchHandlerIface {
 public:
    virtual ~P4RuntimeArchHandlerIface() {}
    virtual cstring getControlPlaneName(const IR::Block *block) {
        auto decl = block->getContainer();
        return decl ? decl->controlPlaneName() : cstring::empty;
    }
    virtual void collectTableProperties(P4RuntimeSymbolTableIface *symbols,
                                        const IR::TableBlock *tableBlock) = 0;
    virtual void collectExternInstance(P4RuntimeSymbolTableIface *symbols,
                                       const IR::ExternBlock *externBlock) = 0;
    virtual void collectAssignmentStatement(P4RuntimeSymbolTableIface *symbols,
                                            const IR::AssignmentStatement *assign) = 0;
    virtual void collectExternMethod(P4RuntimeSymbolTableIface *symbols,
                                     const P4::ExternMethod *externMethod) = 0;
    virtual void collectExternFunction(P4RuntimeSymbolTableIface *symbols,
                                       const P4::ExternFunction *externFunction) = 0;
    virtual void collectExtra(P4RuntimeSymbolTableIface *symbols) = 0;
    virtual void postCollect(const P4RuntimeSymbolTableIface &symbols) = 0;
    virtual void addTableProperties(const P4RuntimeSymbolTableIface &symbols,
                                    ::p4::config::v1::P4Info *p4info,
                                    ::p4::config::v1::Table *table,
                                    const IR::TableBlock *tableBlock) = 0;
    virtual void addExternInstance(const P4RuntimeSymbolTableIface &symbols,
                                   ::p4::config::v1::P4Info *p4info,
                                   const IR::ExternBlock *externBlock) = 0;
    virtual void addExternFunction(const P4RuntimeSymbolTableIface &symbols,
                                   ::p4::config::v1::P4Info *p4info,
                                   const P4::ExternFunction *externFunction) = 0;
    virtual void postAdd(const P4RuntimeSymbolTableIface &symbols,
                         ::p4::config::v1::P4Info *p4info) = 0;
    virtual void addExternEntries(const p4::v1::WriteRequest *entries,
                                  const P4RuntimeSymbolTableIface &symbols,
                                  const IR::ExternBlock *externBlock) = 0;
    virtual bool filterAnnotations(cstring anno) = 0;
 
    virtual google::protobuf::util::JsonPrintOptions getJsonPrintOptions() = 0;
};
 
struct P4RuntimeArchHandlerBuilderIface {
    virtual ~P4RuntimeArchHandlerBuilderIface() {}
 
    virtual P4RuntimeArchHandlerIface *operator()(
        ReferenceMap *refMap, TypeMap *typeMap,
        const IR::ToplevelBlock *evaluatedProgram) const = 0;
};
 
namespace Helpers {
 
std::optional<ExternInstance> getExternInstanceFromProperty(const IR::P4Table *table,
                                                            const cstring &propertyName,
                                                            ReferenceMap *refMap, TypeMap *typeMap,
                                                            bool *isConstructedInPlace = nullptr);
 
bool isExternPropertyConstructedInPlace(const IR::P4Table *table, const cstring &propertyName);
 
template <typename Func>
void forAllEvaluatedBlocks(const IR::Block *block, Func function) {
    std::set<const IR::Block *> visited;
    ordered_set<const IR::Block *> frontier{block};
 
    while (!frontier.empty()) {
        // Pop a block off the frontier of blocks we haven't yet visited.
        auto evaluatedBlock = *frontier.begin();
        frontier.erase(frontier.begin());
        visited.insert(evaluatedBlock);
 
        function(evaluatedBlock);
 
        // Add child blocks to the frontier if we haven't already visited them.
        for (auto evaluatedChild : evaluatedBlock->constantValue) {
            // child block may be nullptr due to optional argument.
            if (!evaluatedChild.second) continue;
            if (!evaluatedChild.second->is<IR::Block>()) continue;
            auto evaluatedChildBlock = evaluatedChild.second->to<IR::Block>();
            if (visited.find(evaluatedChildBlock) != visited.end()) continue;
            frontier.insert(evaluatedChildBlock);
        }
    }
}
 
std::string serializeOneAnnotation(const IR::Annotation *annotation);
 
void serializeOneStructuredAnnotation(const IR::Annotation *annotation,
                                      ::p4::config::v1::StructuredAnnotation *structuredAnnotation);
 
template <typename Message, typename UnaryPredicate>
void addAnnotations(Message *message, const IR::IAnnotated *annotated, UnaryPredicate p) {
    CHECK_NULL(message);
 
    // Synthesized resources may have no annotations.
    if (annotated == nullptr) return;
 
    for (const IR::Annotation *annotation : annotated->getAnnotations()) {
        // Always add all structured annotations.
        if (annotation->annotationKind() != IR::Annotation::Kind::Unstructured &&
            annotation->annotationKind() != IR::Annotation::Kind::Unparsed) {
            serializeOneStructuredAnnotation(annotation, message->add_structured_annotations());
            continue;
        }
        // Don't output the @name or @id annotations; they're represented
        // elsewhere in P4Info messages.
        if (annotation->name == IR::Annotation::nameAnnotation) continue;
        if (annotation->name == "id") continue;
 
        // Don't output the @brief or @description annotations; they're
        // represented using the documentation fields.
        if (annotation->name == "brief" || annotation->name == "description") continue;
 
        if (p(annotation->name)) continue;
 
        message->add_annotations(serializeOneAnnotation(annotation));
    }
}
 
template <typename Message>
void addAnnotations(Message *message, const IR::IAnnotated *annotated) {
    addAnnotations(message, annotated, [](cstring) { return false; });
}
 
template <typename Message>
void addDocumentation(Message *message, const IR::IAnnotated *annotated) {
    CHECK_NULL(message);
 
    // Synthesized resources may have no annotations.
    if (annotated == nullptr) return;
 
    ::p4::config::v1::Documentation doc;
    bool hasDoc = false;
 
    // we iterate over all annotations looking for '@brief' and / or
    // '@description'. As per the P4Runtime spec, we only set the 'doc' field in
    // the message if at least one of them is present.
    for (const IR::Annotation *annotation : annotated->getAnnotations()) {
        if (annotation->name == "brief") {
            auto brief = annotation->getExpr(0)->to<IR::StringLiteral>();
            // guaranteed by ParseAnnotations pass
            CHECK_NULL(brief);
            doc.set_brief(brief->value);
            hasDoc = true;
            continue;
        }
        if (annotation->name == "description") {
            auto description = annotation->getExpr(0)->to<IR::StringLiteral>();
            // guaranteed by ParseAnnotations pass
            CHECK_NULL(description);
            doc.set_description(description->value);
            hasDoc = true;
            continue;
        }
    }
 
    if (hasDoc) message->mutable_doc()->CopyFrom(doc);
}
 
template <typename UnaryPredicate>
void setPreamble(::p4::config::v1::Preamble *preamble, p4rt_id_t id, cstring name, cstring alias,
                 const IR::IAnnotated *annotated, UnaryPredicate p) {
    CHECK_NULL(preamble);
    preamble->set_id(id);
    preamble->set_name(name);
    preamble->set_alias(alias);
    addAnnotations(preamble, annotated, p);
    addDocumentation(preamble, annotated);
}
 
inline void setPreamble(::p4::config::v1::Preamble *preamble, p4rt_id_t id, cstring name,
                        cstring alias, const IR::IAnnotated *annotated) {
    setPreamble(preamble, id, name, alias, annotated, [](cstring) { return false; });
}
 
int64_t getTableSize(const IR::P4Table *table);
 
template <typename Kind>
struct CounterlikeTraits;  // IWYU pragma: keep
 
template <typename Kind>
struct Counterlike {
    const cstring name;
    const IR::IAnnotated *annotations;
    const cstring unit;
    const int64_t size;
    const std::optional<cstring> table;
    const cstring index_type_name;
 
    static std::optional<Counterlike<Kind>> from(const IR::ExternBlock *instance,
                                                 const ReferenceMap *refMap, P4::TypeMap *typeMap,
                                                 ::p4::config::v1::P4TypeInfo *p4RtTypeInfo) {
        CHECK_NULL(instance);
        auto declaration = instance->node->to<IR::Declaration_Instance>();
 
        // Counter and meter externs refer to their unit as a "type"; this is
        // (confusingly) unrelated to the "type" field of a counter or meter in
        // P4Info.
        auto unit = instance->getParameterValue("type"_cs);
        if (!unit->is<IR::Declaration_ID>()) {
            ::P4::error(ErrorType::ERR_INVALID,
                        "%1% '%2%' has a unit type which is not an enum constant: %3%",
                        CounterlikeTraits<Kind>::name(), declaration, unit);
            return std::nullopt;
        }
 
        auto size = instance->getParameterValue(CounterlikeTraits<Kind>::sizeParamName());
        big_int val;
        if (size->template is<IR::Constant>()) {
            val = size->template to<IR::Constant>()->value;
        } else if (size->template is<IR::SerEnumMember>()) {
            auto sem = size->template to<IR::SerEnumMember>();
            val = sem->value->template to<IR::Constant>()->value;
        } else {
            ::P4::error(ErrorType::ERR_INVALID, "%1% '%2%' has a non-constant size: %3%",
                        CounterlikeTraits<Kind>::name(), declaration, size);
            return std::nullopt;
        }
 
        cstring index_type_name = nullptr;
        auto indexTypeParamIdx = CounterlikeTraits<Kind>::indexTypeParamIdx();
        // In v1model, the index is a bit<32>, in PSA it is determined by a type parameter.
        if (indexTypeParamIdx != std::nullopt) {
            // retrieve type parameter for the index.
            BUG_CHECK(declaration->type->is<IR::Type_Specialized>(),
                      "%1%: expected Type_Specialized", declaration->type);
            auto type = declaration->type->to<IR::Type_Specialized>();
            BUG_CHECK(type->arguments->size() > *indexTypeParamIdx,
                      "%1%: expected at least %2% type arguments", instance,
                      *indexTypeParamIdx + 1);
            auto typeArg = type->arguments->at(*indexTypeParamIdx);
            // We ignore the return type on purpose, but the call is required to update p4RtTypeInfo
            // if the index has a user-defined type.
            TypeSpecConverter::convert(refMap, typeMap, typeArg, p4RtTypeInfo);
            index_type_name = getTypeName(typeArg, typeMap);
        }
 
        return Counterlike<Kind>{declaration->controlPlaneName(),
                                 declaration->to<IR::IAnnotated>(),
                                 unit->to<IR::Declaration_ID>()->name,
                                 int(val),
                                 std::nullopt,
                                 index_type_name};
    }
 
    static std::optional<Counterlike<Kind>> fromDirect(const ExternInstance &instance,
                                                       const IR::P4Table *table) {
        CHECK_NULL(table);
        BUG_CHECK(instance.name != std::nullopt, "Caller should've ensured we have a name");
 
        if (instance.type->name != CounterlikeTraits<Kind>::directTypeName()) {
            ::P4::error(ErrorType::ERR_EXPECTED, "Expected a direct %1%: %2%",
                        CounterlikeTraits<Kind>::name(), instance.expression);
            return std::nullopt;
        }
 
        auto unitArgument = instance.substitution.lookupByName("type"_cs)->expression;
        if (unitArgument == nullptr) {
            ::P4::error(ErrorType::ERR_EXPECTED,
                        "Direct %1% instance %2% should take a constructor argument",
                        CounterlikeTraits<Kind>::name(), instance.expression);
            return std::nullopt;
        }
        if (!unitArgument->is<IR::Member>()) {
            ::P4::error(ErrorType::ERR_UNEXPECTED,
                        "Direct %1% instance %2% has an unexpected constructor argument",
                        CounterlikeTraits<Kind>::name(), instance.expression);
            return std::nullopt;
        }
 
        auto unit = unitArgument->to<IR::Member>()->member.name;
        return Counterlike<Kind>{*instance.name,
                                 instance.annotations,
                                 unit,
                                 Helpers::getTableSize(table),
                                 table->controlPlaneName(),
                                 cstring::empty};
    }
};
 
template <typename Kind>
std::optional<Counterlike<Kind>> getDirectCounterlike(const IR::P4Table *table,
                                                      ReferenceMap *refMap, TypeMap *typeMap) {
    auto propertyName = CounterlikeTraits<Kind>::directPropertyName();
    auto instance = getExternInstanceFromProperty(table, propertyName, refMap, typeMap);
    if (!instance) return std::nullopt;
    return Counterlike<Kind>::fromDirect(*instance, table);
}
 
}  // namespace Helpers
 
}  // namespace ControlPlaneAPI
 
 /* end group control_plane */
}  // namespace P4
 
#endif /* CONTROL_PLANE_P4RUNTIMEARCHHANDLER_H_ */