elim_cast.h

 
#ifndef BF_P4C_MIDEND_ELIM_CAST_H_
#define BF_P4C_MIDEND_ELIM_CAST_H_
 
#include "bf-p4c/midend/type_checker.h"
#include "frontends/p4/simplify.h"
#include "frontends/p4/strengthReduction.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
 
namespace BFN {
 
class IgnoreKeyElementTransform : public Transform {
 public:
    const IR::Node *preorder(IR::KeyElement *n) final {
        prune();
        return n;
    }
};
 
class EliminateWidthCasts : public IgnoreKeyElementTransform {
 public:
    static constexpr int MAX_CONTAINER_SIZE = 32;
 
    EliminateWidthCasts() {}
    const IR::Node *preorder(IR::Cast *cast) override;
 
#if 0
    // Caveat(hanw): do not simplify cast in apply functions.
    // stateful_alu implementation must handle '++'
    // before we can eliminate cast.
    const IR::Node* preorder(IR::Function* func) override {
        prune();
        return func; }
#endif
 
    // Caveat(hanw): we do not simplify the cast in a selection expression,
    // because we do not support '++' operator with a constant lhs.
    // Further, simplifying the selection expression has impact on
    // pvs control plan API generation that needs to be discussed with
    // Steve and Yuan.
    const IR::Node *preorder(IR::SelectExpression *expr) override {
        prune();
        return expr;
    }
};
 
class RewriteCastToReinterpretCast : public IgnoreKeyElementTransform {
    P4::TypeMap *typeMap;
 
 public:
    explicit RewriteCastToReinterpretCast(P4::TypeMap *typeMap) : typeMap(typeMap) {}
    const IR::Node *preorder(IR::Cast *expression) override;
};
 
class SimplifyRedundantCasts : public IgnoreKeyElementTransform {
 public:
    SimplifyRedundantCasts() {}
    const IR::Node *preorder(IR::Cast *expression) override;
};
 
class SimplifyNestedCasts : public IgnoreKeyElementTransform {
 public:
    SimplifyNestedCasts() {}
    const IR::Node *preorder(IR::Cast *expression) override;
};
 
class SimplifyOperationBinary : public IgnoreKeyElementTransform {
 public:
    SimplifyOperationBinary() {}
    const IR::Node *preorder(IR::Cast *expression) override;
};
 
class RewriteConcatToSlices : public IgnoreKeyElementTransform {
 public:
    // do not simplify '++' in apply functions.
    const IR::Node *preorder(IR::Function *func) override {
        prune();
        return func;
    }
 
    // do not simplify '++' in deparser block.
    const IR::Node *preorder(IR::BFN::TnaDeparser *dprsr) override {
        prune();
        return dprsr;
    }
 
    const IR::BlockStatement *preorder(IR::BlockStatement *blk) override {
        if (blk->getAnnotation("in_hash"_cs)) prune();
        return blk;
    }
    const IR::Node *preorder(IR::AssignmentStatement *stmt) override;
    const IR::Node *postorder(IR::AssignmentStatement *stmt) override;
    const IR::Node *preorder(IR::IfStatement *stmt) override;
    const IR::Node *preorder(IR::Equ *eq) override;
    const IR::Node *preorder(IR::Neq *ne) override;
};
 
class StrengthReduction : public PassManager {
 public:
    StrengthReduction(P4::ReferenceMap *refMap, P4::TypeMap *typeMap) {
        passes.push_back(new BFN::TypeChecking(refMap, typeMap, true));
        passes.push_back(new P4::DoStrengthReduction());
    }
};
 
class ElimCasts : public PassManager {
 public:
    ElimCasts(P4::ReferenceMap *refMap, P4::TypeMap *typeMap) {
        addPasses({
            new SimplifyOperationBinary(),
            new PassRepeated({new SimplifyNestedCasts(), new SimplifyRedundantCasts()}),
            new RewriteCastToReinterpretCast(typeMap),
            new EliminateWidthCasts(),
            // EliminateWidthCasts might change some of the Type_Bits
            // to different objects representing the same type =>
            // rerun typechecking with empty typemap to properly
            // unify those new types
            new P4::ClearTypeMap(typeMap),
            new BFN::TypeChecking(refMap, typeMap, true),
            // FIXME -- StrengthReduction has problems with complex nested things like
            // (0 ++ field << 1)[15:0] which causes problems for Rewrite
            // so we repeat until a fixed point is reached.
            new PassRepeated({new StrengthReduction(refMap, typeMap)}),
            new RewriteConcatToSlices(),
            new P4::ClearTypeMap(typeMap),
            new BFN::TypeChecking(refMap, typeMap, true),
            new P4::SimplifyControlFlow(typeMap),
            new P4::ClearTypeMap(typeMap),
            new BFN::TypeChecking(refMap, typeMap, true),
        });
    }
};
 
}  // namespace BFN
 
#endif /* BF_P4C_MIDEND_ELIM_CAST_H_ */