constantFolding.h

/*
Copyright 2013-present Barefoot Networks, Inc.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#ifndef COMMON_CONSTANTFOLDING_H_
#define COMMON_CONSTANTFOLDING_H_
 
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
#include "lib/big_int_util.h"
 
namespace P4 {
 
class ConstantFoldingPolicy {
 public:
    virtual const IR::Node *hook(Visitor &, IR::PathExpression *) { return nullptr; }
};
 
class DoConstantFolding : public Transform {
 protected:
    ConstantFoldingPolicy *policy;
 
    const ReferenceMap *refMap;
 
    const TypeMap *typeMap;
 
    bool typesKnown;
 
    bool warnings;
 
    std::map<const IR::Declaration_Constant *, const IR::Expression *> constants;
    // True if we are processing a left side of an assignment; we should not
    // we substituting constants there.
    bool assignmentTarget;
 
    const IR::Expression *getConstant(const IR::Expression *expr) const;
 
    const IR::Constant *cast(const IR::Constant *node, unsigned base,
                             const IR::Type_Bits *type) const;
 
    const IR::Node *binary(const IR::Operation_Binary *op,
                           std::function<big_int(big_int, big_int)> func, bool saturating = false);
    const IR::Node *compare(const IR::Operation_Binary *op);
 
    const IR::Node *shift(const IR::Operation_Binary *op);
 
    enum class Result { Yes, No, DontKnow };
 
    Result setContains(const IR::Expression *keySet, const IR::Expression *constant) const;
 
 public:
    DoConstantFolding(const ReferenceMap *refMap, const TypeMap *typeMap, bool warnings = true,
                      ConstantFoldingPolicy *policy = nullptr)
        : refMap(refMap), typeMap(typeMap), typesKnown(typeMap != nullptr), warnings(warnings) {
        if (policy) {
            this->policy = policy;
        } else {
            this->policy = new ConstantFoldingPolicy();
        }
        visitDagOnce = true;
        setName("DoConstantFolding");
        assignmentTarget = false;
    }
 
    const IR::Node *postorder(IR::Declaration_Constant *d) override;
    const IR::Node *postorder(IR::PathExpression *e) override;
    const IR::Node *postorder(IR::Cmpl *e) override;
    const IR::Node *postorder(IR::Neg *e) override;
    const IR::Node *postorder(IR::UPlus *e) override;
    const IR::Node *postorder(IR::LNot *e) override;
    const IR::Node *postorder(IR::LAnd *e) override;
    const IR::Node *postorder(IR::LOr *e) override;
    const IR::Node *postorder(IR::Slice *e) override;
    const IR::Node *postorder(IR::Add *e) override;
    const IR::Node *postorder(IR::AddSat *e) override;
    const IR::Node *postorder(IR::Sub *e) override;
    const IR::Node *postorder(IR::SubSat *e) override;
    const IR::Node *postorder(IR::Mul *e) override;
    const IR::Node *postorder(IR::Div *e) override;
    const IR::Node *postorder(IR::Mod *e) override;
    const IR::Node *postorder(IR::BXor *e) override;
    const IR::Node *postorder(IR::BAnd *e) override;
    const IR::Node *postorder(IR::BOr *e) override;
    const IR::Node *postorder(IR::Equ *e) override;
    const IR::Node *postorder(IR::Neq *e) override;
    const IR::Node *postorder(IR::Lss *e) override;
    const IR::Node *postorder(IR::Grt *e) override;
    const IR::Node *postorder(IR::Leq *e) override;
    const IR::Node *postorder(IR::Geq *e) override;
    const IR::Node *postorder(IR::Shl *e) override;
    const IR::Node *postorder(IR::Shr *e) override;
    const IR::Node *postorder(IR::Concat *e) override;
    const IR::Node *postorder(IR::Member *e) override;
    const IR::Node *postorder(IR::Cast *e) override;
    const IR::Node *postorder(IR::Mux *e) override;
    const IR::Node *postorder(IR::Type_Bits *type) override;
    const IR::Node *postorder(IR::Type_Varbits *type) override;
    const IR::Node *postorder(IR::SelectExpression *e) override;
    const IR::Node *postorder(IR::IfStatement *statement) override;
    const IR::Node *preorder(IR::AssignmentStatement *statement) override;
    const IR::Node *preorder(IR::ArrayIndex *e) override;
    const IR::BlockStatement *preorder(IR::BlockStatement *bs) override {
        if (bs->annotations->getSingle("disable_optimization")) prune();
        return bs;
    }
};
 
class ConstantFolding : public PassManager {
 public:
    ConstantFolding(ReferenceMap *refMap, TypeMap *typeMap, ConstantFoldingPolicy *policy)
        : ConstantFolding(refMap, typeMap, true, nullptr, policy) {}
 
    ConstantFolding(ReferenceMap *refMap, TypeMap *typeMap, bool warnings = true,
                    TypeChecking *typeChecking = nullptr, ConstantFoldingPolicy *policy = nullptr) {
        if (typeMap != nullptr) {
            if (!typeChecking) typeChecking = new TypeChecking(refMap, typeMap);
            passes.push_back(typeChecking);
        }
        passes.push_back(new DoConstantFolding(refMap, typeMap, warnings, policy));
        if (typeMap != nullptr) passes.push_back(new ClearTypeMap(typeMap));
        setName("ConstantFolding");
    }
};
 
}  // namespace P4
 
#endif /* COMMON_CONSTANTFOLDING_H_ */