backends/tofino/bf-p4c/common/alias.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_COMMON_ALIAS_H_
#define BACKENDS_TOFINO_BF_P4C_COMMON_ALIAS_H_
 
#include "bf-p4c/bf-p4c-options.h"
#include "bf-p4c/logging/pass_manager.h"
#include "bf-p4c/phv/phv_fields.h"
#include "bf-p4c/phv/pragma/pa_alias.h"
#include "bf-p4c/phv/transforms/auto_alias.h"
#include "ir/ir.h"
 
using namespace P4;
 
class FindExpressionsForFields : public Inspector {
 private:
    ordered_map<cstring, const IR::Member *> &fieldNameToExpressionsMap;
 
    profile_t init_apply(const IR::Node *root) override;
    bool preorder(const IR::HeaderOrMetadata *h) override;
 
 public:
    FindExpressionsForFields(const PhvInfo &, ordered_map<cstring, const IR::Member *> &f)
        : fieldNameToExpressionsMap(f) {}
};
 
class ReplaceAllAliases : public Transform {
 private:
    const PhvInfo &phv;
    const PragmaAlias &pragmaAlias;
    const ordered_map<cstring, const IR::Member *> &fieldExpressions;
 
    profile_t init_apply(const IR::Node *root) override;
    IR::Node *preorder(IR::BFN::Pipe *) override;
    IR::Node *preorder(IR::Expression *expr) override;
 
 public:
    ReplaceAllAliases(const PhvInfo &p, const PragmaAlias &pragmaAlias,
                      const ordered_map<cstring, const IR::Member *> &f)
        : phv(p), pragmaAlias(pragmaAlias), fieldExpressions(f) {}
};
 
class AddValidityBitSets : public Transform {
 private:
    const PhvInfo &phv;
    const PragmaAlias &pragmaAlias;
 
    ordered_map<const PHV::Field *, ordered_set<const PHV::Field *>> aliasedFields;
    ordered_map<cstring, ordered_set<const PHV::Field *>> actionToPOVMap;
 
    inline cstring getFieldValidityName(cstring origName);
 
    profile_t init_apply(const IR::Node *root) override;
    IR::Node *preorder(IR::MAU::Instruction *inst) override;
    IR::Node *postorder(IR::MAU::Action *action) override;
 
 public:
    explicit AddValidityBitSets(const PhvInfo &p, const PragmaAlias &pa)
        : phv(p), pragmaAlias(pa) {}
};
 
class Alias : public Logging::PassManager {
 private:
    ordered_map<cstring, const IR::Member *> fieldExpressions;
    const PragmaAlias &pragmaAlias;
 
 public:
    explicit Alias(PhvInfo &phv, const PragmaAlias &pa)
        : Logging::PassManager("pragmas"_cs, Logging::Mode::AUTO), pragmaAlias(pa) {
        addPasses({new FindExpressionsForFields(phv, fieldExpressions),
                   new AddValidityBitSets(phv, pragmaAlias),
                   new ReplaceAllAliases(phv, pragmaAlias, fieldExpressions),
                   new VisitFunctor([this]() {
                       if (LOGGING(1)) {
                           LOG1(pragmaAlias.pretty_print());
                       }
                   })});
    }
};
 
class ReinstateAliasSources : public Transform {
    PhvInfo &phv;
 
    IR::Node *preorder(IR::BFN::AliasMember *alias) override {
        const PHV::Field *aliasSource = phv.field(alias->source);
        const PHV::Field *aliasDestination = phv.field(alias);
        BUG_CHECK(aliasSource, "Field %1% not found", alias->source);
        BUG_CHECK(aliasDestination, "Field %1% not found", alias);
        phv.addAliasMapEntry(aliasSource, aliasDestination);
        return alias->source->apply(ReinstateAliasSources(phv))->clone();
    }
 
    IR::Node *preorder(IR::BFN::AliasSlice *alias) override {
        const PHV::Field *aliasSource = phv.field(alias->source);
        const PHV::Field *aliasDestination = phv.field(alias);
        BUG_CHECK(aliasSource, "Field %1% not found", alias->source);
        BUG_CHECK(aliasDestination, "Field %1% not found", alias);
        phv.addAliasMapEntry(aliasSource, aliasDestination);
        return alias->source->apply(ReinstateAliasSources(phv))->clone();
    }
 
 public:
    explicit ReinstateAliasSources(PhvInfo &p) : phv(p) {}
};
 
#endif /* BACKENDS_TOFINO_BF_P4C_COMMON_ALIAS_H_ */