bmv2/common/backend.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_BMV2_COMMON_BACKEND_H_
#define BACKENDS_BMV2_COMMON_BACKEND_H_
 
#include "JsonObjects.h"
#include "controlFlowGraph.h"
#include "expression.h"
#include "frontends/common/model.h"
#include "frontends/p4/coreLibrary.h"
#include "helpers.h"
#include "ir/annotations.h"
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/error.h"
#include "lib/exceptions.h"
#include "lib/gc.h"
#include "lib/json.h"
#include "lib/log.h"
#include "lib/nullstream.h"
#include "midend/actionSynthesis.h"
#include "midend/convertEnums.h"
#include "midend/removeComplexExpressions.h"
#include "midend/removeLeftSlices.h"
#include "options.h"
#include "sharedActionSelectorCheck.h"
 
namespace P4::BMV2 {
 
enum gress_t { INGRESS, EGRESS };
enum block_t {
    PARSER,
    PIPELINE,
    DEPARSER,
    V1_PARSER,
    V1_DEPARSER,
    V1_INGRESS,
    V1_EGRESS,
    V1_VERIFY,
    V1_COMPUTE
};
 
class ExpressionConverter;

class Backend {
 public:
    BMV2Options &options;
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    P4::ConvertEnums::EnumMapping *enumMap;
    P4::P4CoreLibrary &corelib;
    BMV2::JsonObjects *json;
    const IR::ToplevelBlock *toplevel = nullptr;
 
 public:
    Backend(BMV2Options &options, P4::ReferenceMap *refMap, P4::TypeMap *typeMap,
            P4::ConvertEnums::EnumMapping *enumMap)
        : options(options),
          refMap(refMap),
          typeMap(typeMap),
          enumMap(enumMap),
          corelib(P4::P4CoreLibrary::instance()),
          json(new BMV2::JsonObjects()) {
        refMap->setIsV1(options.isv1());
    }
    void serialize(std::ostream &out) const { json->toplevel->serialize(out); }
    virtual void convert(const IR::ToplevelBlock *block) = 0;
};

// The policy is: do not synthesize actions for the controls whose names
class SkipControls : public P4::ActionSynthesisPolicy {
    const std::set<cstring> *skip;
 
 public:
    explicit SkipControls(const std::set<cstring> *skip) : skip(skip) { CHECK_NULL(skip); }
    bool convert(const Visitor::Context *, const IR::P4Control *control) override {
        if (skip->find(control->name) != skip->end()) return false;
        return true;
    }
};

class ProcessControls : public P4::RemoveComplexExpressionsPolicy {
    const std::set<cstring> *process;
 
 public:
    explicit ProcessControls(const std::set<cstring> *process) : process(process) {
        CHECK_NULL(process);
    }
    bool convert(const IR::P4Control *control) const {
        if (process->find(control->name) != process->end()) return true;
        return false;
    }
};

class RenameUserMetadata : public Transform {
    P4::ReferenceMap *refMap;
    const IR::Type_Struct *userMetaType;
    cstring namePrefix;
    bool renamed = false;
 
 public:
    RenameUserMetadata(P4::ReferenceMap *refMap, const IR::Type_Struct *userMetaType,
                       cstring namePrefix)
        : refMap(refMap), userMetaType(userMetaType), namePrefix(namePrefix) {
        setName("RenameUserMetadata");
        CHECK_NULL(refMap);
        visitDagOnce = false;
    }
 
    const IR::Node *postorder(IR::Type_Struct *type) override {
        // Clone the user metadata type
        auto orig = getOriginal<IR::Type_Struct>();
        if (userMetaType->name != orig->name) return type;
 
        auto vec = new IR::IndexedVector<IR::Node>();
        LOG2("Creating clone of " << orig);
        renamed = true;
        auto clone = type->clone();
        clone->name = namePrefix;
        vec->push_back(clone);
 
        // Rename all fields
        IR::IndexedVector<IR::StructField> fields;
        for (auto f : type->fields) {
            auto anno = f->getAnnotation(IR::Annotation::nameAnnotation);
            cstring suffix = cstring::empty;
            if (anno != nullptr) suffix = anno->getName();
            if (suffix.startsWith(".")) {
                // We can't change the name of this field.
                // Hopefully the user knows what they are doing.
                fields.push_back(f->clone());
                continue;
            }
 
            if (!suffix.isNullOrEmpty())
                suffix = "."_cs + suffix;
            else
                suffix = "."_cs + f->name;
            cstring newName = namePrefix + suffix;
            LOG2("Renaming " << f << " to " << newName);
            auto field = new IR::StructField(
                f->srcInfo, f->name, IR::Annotations::setNameAnnotation(f->annotations, newName),
                f->type);
            fields.push_back(field);
        }
 
        auto annotated =
            new IR::Type_Struct(type->srcInfo, type->name, type->annotations, std::move(fields));
        vec->push_back(annotated);
        return vec;
    }
 
    const IR::Node *preorder(IR::Type_Name *type) override {
        // Find any reference to the user metadata type that is used and replace them
        auto decl = refMap->getDeclaration(type->path);
        if (decl == userMetaType)
            type->path = new IR::Path(type->path->srcInfo, IR::ID(type->path->srcInfo, namePrefix));
        LOG2("Replacing reference with " << type);
        return type;
    }
 
    void end_apply(const IR::Node *) override {
        BUG_CHECK(renamed, "Could not identify user metadata type declaration %1%", userMetaType);
    }
};
 
}  // namespace P4::BMV2
 
#endif /* BACKENDS_BMV2_COMMON_BACKEND_H_ */