extract_deparser.h

 
#ifndef BF_P4C_PARDE_EXTRACT_DEPARSER_H_
#define BF_P4C_PARDE_EXTRACT_DEPARSER_H_
 
#include "backends/tofino/bf-p4c/arch/bridge_metadata.h"
#include "backends/tofino/bf-p4c/bf-p4c-options.h"
#include "backends/tofino/bf-p4c/common/ir_utils.h"
#include "backends/tofino/bf-p4c/common/pragma/all_pragmas.h"
#include "backends/tofino/bf-p4c/common/pragma/collect_global_pragma.h"
#include "backends/tofino/bf-p4c/device.h"
#include "backends/tofino/bf-p4c/ir/gress.h"
#include "backends/tofino/bf-p4c/parde/parde_visitor.h"
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/exceptions.h"
 
namespace P4 {
namespace IR {
 
namespace BFN {
class Pipe;
}  // namespace BFN
 
class P4Control;
 
}  // namespace IR
}  // namespace P4
 
namespace BFN {
 
using namespace P4;
class ExtractDeparser : public DeparserInspector {
    P4::TypeMap *typeMap;
    P4::ReferenceMap *refMap;
    IR::BFN::Pipe *rv;
    IR::BFN::Deparser *dprsr = nullptr;
    ordered_map<cstring, IR::BFN::Digest *> digests;
 
    ordered_map<cstring, std::vector<const IR::BFN::EmitField *>> headerToEmits;
 
    std::set<ordered_set<cstring> *> userEnforcedHeaderOrdering;
 
    void generateEmits(const IR::MethodCallExpression *mc);
    void generateDigest(IR::BFN::Digest *&digest, cstring name, const IR::Expression *list,
                        const IR::Expression *select, int digest_index,
                        cstring controlPlaneName = nullptr);
    void convertConcatToList(std::vector<const IR::Expression *> &slices, const IR::Concat *expr);
    void processConcat(IR::Vector<IR::BFN::FieldLVal> &vec, const IR::Concat *expr);
 
    std::tuple<int, const IR::Expression *> getDigestIndex(const IR::IfStatement *, cstring name,
                                                           bool singleEntry = false);
    int getDigestIndex(const IR::Declaration_Instance *);
    void processMirrorEmit(const IR::MethodCallExpression *, const IR::Expression *, int idx);
    void processMirrorEmit(const IR::MethodCallExpression *, int idx);
    void processResubmitEmit(const IR::MethodCallExpression *, const IR::Expression *, int idx);
    void processResubmitEmit(const IR::MethodCallExpression *, int idx);
    void processDigestPack(const IR::MethodCallExpression *, int, cstring);
    void enforceHeaderOrdering();
 
    IR::ID getTnaParamName(const IR::BFN::TnaDeparser *deparser, IR::ID orig_name);
 
    bool preorder(const IR::Annotation *annot) override;
    bool preorder(const IR::AssignmentStatement *stmt) override;
    void postorder(const IR::MethodCallExpression *mc) override;
    void end_apply() override;
 
 public:
    explicit ExtractDeparser(P4::ReferenceMap *refMap, P4::TypeMap *typeMap, IR::BFN::Pipe *rv)
        : typeMap(typeMap), refMap(refMap), rv(rv) {
        setName("ExtractDeparser");
    }
 
    bool preorder(const IR::BFN::TnaDeparser *deparser) override {
        gress_t thread = deparser->thread;
        dprsr = new IR::BFN::Deparser(thread);
        digests.clear();
        return true;
    }
 
    void postorder(const IR::BFN::TnaDeparser *deparser) override {
        for (const auto &kv : digests) {
            auto name = kv.first;
            auto digest = kv.second;
            if (!digest) continue;
            for (auto fieldList : digest->fieldLists) {
                if (fieldList->idx < 0 ||
                    fieldList->idx > static_cast<int>(Device::maxCloneId(deparser->thread))) {
                    error("Invalid %1% index %2% in %3%", name, fieldList->idx,
                          int(deparser->thread));
                }
            }
        }
        rv->thread[deparser->thread].deparser = dprsr;
    }
};
// in mirror, digest or resubmit.
struct AssignmentStmtErrorCheck : public DeparserInspector {
    const IR::Type *left = nullptr;
    bool stmtOk = false;
    explicit AssignmentStmtErrorCheck(const IR::Type *left) : left(left) {}
 
    void postorder(const IR::MethodCallExpression *methodCall) override {
        auto member = methodCall->method->to<IR::Member>();
        auto expr = member->expr->to<IR::PathExpression>();
        if (!expr) return;
        const IR::Type_Extern *type = nullptr;
        if (auto spType = expr->type->to<IR::Type_SpecializedCanonical>()) {
            type = spType->baseType->to<IR::Type_Extern>();
        } else {
            type = expr->type->to<IR::Type_Extern>();
        }
        if (!type) return;
        if (type->name != "Mirror" && type->name != "Digest" && type->name != "Resubmit") {
            return;
        }
        auto arguments = *methodCall->arguments;
        for (auto argument : arguments) {
            if (argument->expression->type->equiv(*left)) {
                stmtOk = true;
                return;
            }
        }
        return;
    }
};
 
}  // namespace BFN
 
#endif /* BF_P4C_PARDE_EXTRACT_DEPARSER_H_ */