simpleSwitch.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_BMV2_SIMPLE_SWITCH_SIMPLESWITCH_H_
#define BACKENDS_BMV2_SIMPLE_SWITCH_SIMPLESWITCH_H_
 
#include <algorithm>
#include <cstring>
 
#include "backends/bmv2/common/action.h"
#include "backends/bmv2/common/backend.h"
#include "backends/bmv2/common/control.h"
#include "backends/bmv2/common/deparser.h"
#include "backends/bmv2/common/extern.h"
#include "backends/bmv2/common/globals.h"
#include "backends/bmv2/common/header.h"
#include "backends/bmv2/common/options.h"
#include "backends/bmv2/common/parser.h"
#include "backends/bmv2/common/sharedActionSelectorCheck.h"
#include "backends/common/programStructure.h"
#include "frontends/common/constantFolding.h"
#include "frontends/p4-14/fromv1.0/v1model.h"
#include "frontends/p4/evaluator/evaluator.h"
#include "frontends/p4/simplify.h"
#include "frontends/p4/unusedDeclarations.h"
#include "midend/convertEnums.h"
 
namespace P4::BMV2 {
 
class V1ProgramStructure : public P4::ProgramStructure {
 public:
    std::set<cstring> pipeline_controls;
    std::set<cstring> non_pipeline_controls;
 
    const IR::P4Parser *parser = nullptr;
    const IR::P4Control *ingress = nullptr;
    const IR::P4Control *egress = nullptr;
    const IR::P4Control *compute_checksum = nullptr;
    const IR::P4Control *verify_checksum = nullptr;
    const IR::P4Control *deparser = nullptr;
 
    V1ProgramStructure() {}
    BlockConverted blockKind(const IR::Node *node) const {
        if (node == parser)
            return BlockConverted::Parser;
        else if (node == ingress)
            return BlockConverted::Ingress;
        else if (node == egress)
            return BlockConverted::Egress;
        else if (node == compute_checksum)
            return BlockConverted::ChecksumCompute;
        else if (node == verify_checksum)
            return BlockConverted::ChecksumVerify;
        else if (node == deparser)
            return BlockConverted::Deparser;
        return BlockConverted::None;
    }
};
 
class SimpleSwitchExpressionConverter : public ExpressionConverter {
    V1ProgramStructure *structure;
 
 public:
    SimpleSwitchExpressionConverter(P4::ReferenceMap *refMap, P4::TypeMap *typeMap,
                                    V1ProgramStructure *structure, cstring scalarsName)
        : ExpressionConverter(refMap, typeMap, structure, scalarsName), structure(structure) {}
 
    void modelError(const char *format, const IR::Node *node) {
        ::P4::errorWithSuffix(ErrorType::ERR_MODEL, format,
                              "\nAre you using an up-to-date v1model.p4?", node);
    }
 
    bool isStandardMetadataParameter(const IR::Parameter *param) {
        auto params = structure->parser->getApplyParameters();
        if (params->size() != 4) {
            modelError("%1%: Expected 4 parameter for parser", structure->parser);
            return false;
        }
        if (params->parameters.at(3) == param) return true;
 
        params = structure->ingress->getApplyParameters();
        if (params->size() != 3) {
            modelError("%1%: Expected 3 parameter for ingress", structure->ingress);
            return false;
        }
        if (params->parameters.at(2) == param) return true;
 
        params = structure->egress->getApplyParameters();
        if (params->size() != 3) {
            modelError("%1%: Expected 3 parameter for egress", structure->egress);
            return false;
        }
        if (params->parameters.at(2) == param) return true;
 
        return false;
    }
 
    Util::IJson *convertParam(const IR::Parameter *param, cstring fieldName) override {
        if (isStandardMetadataParameter(param)) {
            auto result = new Util::JsonObject();
            if (fieldName != "") {
                result->emplace("type", "field");
                auto e = BMV2::mkArrayField(result, "value"_cs);
                e->append("standard_metadata");
                e->append(fieldName);
            } else {
                result->emplace("type", "header");
                result->emplace("value", "standard_metadata");
            }
            return result;
        }
        return nullptr;
    }
};
 
class ParseV1Architecture : public Inspector {
    V1ProgramStructure *structure;
    P4V1::V1Model &v1model;
 
 public:
    explicit ParseV1Architecture(V1ProgramStructure *structure)
        : structure(structure), v1model(P4V1::V1Model::instance) {}
    void modelError(const char *format, const IR::Node *node);
    bool preorder(const IR::PackageBlock *block) override;
};
 
class SimpleSwitchBackend : public Backend {
    BMV2Options &options;
    P4V1::V1Model &v1model;
    V1ProgramStructure *structure = nullptr;
    ExpressionConverter *conv = nullptr;
 
 protected:
    void createRecirculateFieldsList(ConversionContext *ctxt, const IR::ToplevelBlock *tlb,
                                     cstring scalarName);
    cstring createCalculation(cstring algo, const IR::Expression *fields,
                              Util::JsonArray *calculations, bool usePayload, const IR::Node *node);
 
 public:
    void modelError(const char *format, const IR::Node *place) const;
    void convertChecksum(const IR::BlockStatement *body, Util::JsonArray *checksums,
                         Util::JsonArray *calculations, bool verify);
    void createActions(ConversionContext *ctxt, V1ProgramStructure *structure);
 
    void convert(const IR::ToplevelBlock *tlb) override;
    SimpleSwitchBackend(BMV2Options &options, P4::ReferenceMap *refMap, P4::TypeMap *typeMap,
                        P4::ConvertEnums::EnumMapping *enumMap)
        : Backend(options, refMap, typeMap, enumMap),
          options(options),
          v1model(P4V1::V1Model::instance) {}
};
 
EXTERN_CONVERTER_W_FUNCTION(clone)
EXTERN_CONVERTER_W_FUNCTION(clone_preserving_field_list)
EXTERN_CONVERTER_W_FUNCTION_AND_MODEL(hash, P4V1::V1Model, v1model)
EXTERN_CONVERTER_W_FUNCTION(digest)
EXTERN_CONVERTER_W_FUNCTION(resubmit_preserving_field_list)
EXTERN_CONVERTER_W_FUNCTION(recirculate_preserving_field_list)
EXTERN_CONVERTER_W_FUNCTION(mark_to_drop)
EXTERN_CONVERTER_W_FUNCTION(log_msg)
EXTERN_CONVERTER_W_FUNCTION_AND_MODEL(random, P4V1::V1Model, v1model)
EXTERN_CONVERTER_W_FUNCTION_AND_MODEL(truncate, P4V1::V1Model, v1model)
EXTERN_CONVERTER_W_OBJECT_AND_INSTANCE_AND_MODEL(register, P4V1::V1Model, v1model)
EXTERN_CONVERTER_W_OBJECT_AND_INSTANCE_AND_MODEL(counter, P4V1::V1Model, v1model)
EXTERN_CONVERTER_W_OBJECT_AND_INSTANCE_AND_MODEL(meter, P4V1::V1Model, v1model)
EXTERN_CONVERTER_W_OBJECT_AND_INSTANCE(direct_counter)
EXTERN_CONVERTER_W_OBJECT_AND_INSTANCE_AND_MODEL(direct_meter, P4V1::V1Model, v1model)
EXTERN_CONVERTER_W_INSTANCE_AND_MODEL(action_profile, P4V1::V1Model, v1model)
EXTERN_CONVERTER_W_INSTANCE_AND_MODEL(action_selector, P4V1::V1Model, v1model)
 
}  // namespace P4::BMV2
 
#endif /* BACKENDS_BMV2_SIMPLE_SWITCH_SIMPLESWITCH_H_ */