psaProgramStructure.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * SPDX-FileCopyrightText: 2022 VMware Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_COMMON_PSAPROGRAMSTRUCTURE_H_
#define BACKENDS_COMMON_PSAPROGRAMSTRUCTURE_H_
 
#include "portableProgramStructure.h"
 
namespace P4 {
 
enum psa_gress_t {
    INGRESS,
    EGRESS,
};
 
enum block_t {
    PARSER,
    PIPELINE,
    DEPARSER,
};
 
class PsaProgramStructure : public PortableProgramStructure {
 public:
    ordered_map<const IR::Node *, std::pair<psa_gress_t, block_t>> block_type;
 
 public:
    PsaProgramStructure(P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
        : PortableProgramStructure(refMap, typeMap) {}

    static bool isCounterMetadata(cstring ptName) { return ptName == "PSA_CounterType_t"; }

    static bool isStandardMetadata(cstring ptName) {
        return (ptName == "psa_ingress_parser_input_metadata_t" ||
                ptName == "psa_egress_parser_input_metadata_t" ||
                ptName == "psa_ingress_input_metadata_t" ||
                ptName == "psa_ingress_output_metadata_t" ||
                ptName == "psa_egress_input_metadata_t" ||
                ptName == "psa_egress_deparser_input_metadata_t" ||
                ptName == "psa_egress_output_metadata_t");
    }
};
 
class ParsePsaArchitecture : public ParsePortableArchitecture {
    PsaProgramStructure *structure;
 
 public:
    explicit ParsePsaArchitecture(PsaProgramStructure *structure) : structure(structure) {
        CHECK_NULL(structure);
    }
 
    void modelError(const char *format, const IR::INode *node) {
        ::P4::error(ErrorType::ERR_MODEL,
                    (cstring(format) + "\nAre you using an up-to-date 'psa.p4'?").c_str(),
                    node->getNode());
    }
 
    bool preorder(const IR::PackageBlock *block) override;
    bool preorder(const IR::ExternBlock *block) override;
 
    profile_t init_apply(const IR::Node *root) override {
        structure->block_type.clear();
        structure->globals.clear();
        return Inspector::init_apply(root);
    }
};
 
class InspectPsaProgram : public InspectPortableProgram {
    PsaProgramStructure *pinfo;
 
 public:
    InspectPsaProgram(P4::ReferenceMap *refMap, P4::TypeMap *typeMap, PsaProgramStructure *pinfo)
        : InspectPortableProgram(refMap, typeMap), pinfo(pinfo) {
        CHECK_NULL(pinfo);
        setName("InspectPsaProgram");
    }
 
    void postorder(const IR::P4Parser *p) override;
    void postorder(const IR::P4Control *c) override;
    void postorder(const IR::Declaration_Instance *di) override;
 
    void addTypesAndInstances(const IR::Type_StructLike *type, bool meta);
    void addHeaderType(const IR::Type_StructLike *st);
    void addHeaderInstance(const IR::Type_StructLike *st, cstring name);
    bool preorder(const IR::Declaration_Variable *dv) override;
    bool preorder(const IR::Parameter *parameter) override;
};
 
}  // namespace P4
 
#endif /* BACKENDS_COMMON_PSAPROGRAMSTRUCTURE_H_ */