constantFolding.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_COMMON_CONSTANTFOLDING_H_
#define FRONTENDS_COMMON_CONSTANTFOLDING_H_
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {
 
using namespace literals;

class ConstantFoldingPolicy {
 public:
    virtual ~ConstantFoldingPolicy() = default;
    virtual const IR::Node *hook(Visitor &, IR::PathExpression *) { return nullptr; }
};

class DoConstantFolding : public Transform, public ResolutionContext {
 protected:
    ConstantFoldingPolicy *policy;

    const DeclarationLookup *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::Type *resolveType(const IR::Type *t);

    const IR::Expression *getConstant(const IR::Expression *expr) const;

    const IR::Constant *cast(const IR::Constant *node, unsigned base, const IR::Type_Bits *type,
                             bool noWarning = false) 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 DeclarationLookup *refMap, const TypeMap *typeMap, bool warnings = true,
                      ConstantFoldingPolicy *policy = nullptr)
        : policy(policy ? policy : new ConstantFoldingPolicy()),
          refMap(refMap),
          typeMap(typeMap),
          typesKnown(typeMap != nullptr),
          warnings(warnings) {
        visitDagOnce = true;
        setName("DoConstantFolding");
        assignmentTarget = false;
    }
 
    // If DeclarationLookup is not passed, then resolve by our own. We might
    // need proper context for this
    explicit DoConstantFolding(const TypeMap *typeMap, bool warnings = true,
                               ConstantFoldingPolicy *policy = nullptr)
        : DoConstantFolding(this, typeMap, warnings, policy) {}
 
    DoConstantFolding() : DoConstantFolding(nullptr, nullptr) {}
 
    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::PlusSlice *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::BaseAssignmentStatement *statement) override;
    const IR::Node *preorder(IR::ArrayIndex *e) override;
    const IR::Node *preorder(IR::SwitchCase *c) override;
    const IR::BlockStatement *preorder(IR::BlockStatement *bs) override {
        if (bs->hasAnnotation(IR::Annotation::disableOptimizationAnnotation)) prune();
        return bs;
    }
};

class ConstantFolding : public PassManager {
 public:
    ConstantFolding(TypeMap *typeMap, ConstantFoldingPolicy *policy)
        : ConstantFolding(typeMap, true, nullptr, policy) {}
 
    explicit ConstantFolding(ConstantFoldingPolicy *policy)
        : ConstantFolding(nullptr, true, nullptr, policy) {}
 
    explicit ConstantFolding(TypeMap *typeMap, bool warnings = true,
                             TypeChecking *typeChecking = nullptr,
                             ConstantFoldingPolicy *policy = nullptr) {
        if (typeMap != nullptr) {
            if (!typeChecking) typeChecking = new TypeChecking(nullptr, typeMap);
            passes.push_back(typeChecking);
        }
        passes.push_back(new DoConstantFolding(typeMap, warnings, policy));
        if (typeMap != nullptr) passes.push_back(new ClearTypeMap(typeMap));
        setName("ConstantFolding");
    }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_COMMON_CONSTANTFOLDING_H_ */