strengthReduction.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_STRENGTHREDUCTION_H_
#define FRONTENDS_P4_STRENGTHREDUCTION_H_
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/sideEffects.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
 
namespace P4 {
 
using namespace literals;
 
class StrengthReductionPolicy {
 public:
    StrengthReductionPolicy() {}
    StrengthReductionPolicy(bool enableSubConstToAddTransform,
                            bool enableNarrowingCastToSliceTransform)
        : enableSubConstToAddTransform(enableSubConstToAddTransform),
          enableNarrowingCastToSliceTransform(enableNarrowingCastToSliceTransform) {}

    bool enableSubConstToAddTransform = true;

    bool enableNarrowingCastToSliceTransform = false;
};

class DoStrengthReduction final : public Transform {
 protected:
    TypeMap *typeMap = nullptr;
    StrengthReductionPolicy *policy;

    bool isOne(const IR::Expression *expr) const;
    bool isZero(const IR::Expression *expr) const;
    bool isTrue(const IR::Expression *expr) const;
    bool isFalse(const IR::Expression *expr) const;
    bool isAllOnes(const IR::Expression *expr) const;
    int isPowerOf2(const IR::Expression *expr) const;

    bool hasSideEffects(const IR::Expression *expr) const {
        return SideEffects::check(expr, this, nullptr, nullptr);
    }
 
 public:
    DoStrengthReduction(TypeMap *typeMap, StrengthReductionPolicy *policy)
        : typeMap(typeMap), policy(policy ? policy : new StrengthReductionPolicy()) {
        visitDagOnce = true;
        setName("StrengthReduction");
    }
 
    DoStrengthReduction() : DoStrengthReduction(nullptr, nullptr) {}
 
    using Transform::postorder;
 
    const IR::Node *postorder(IR::Cmpl *expr) override;
    const IR::Node *postorder(IR::BAnd *expr) override;
    const IR::Node *postorder(IR::BOr *expr) override;
    const IR::Node *postorder(IR::Equ *expr) override;
    const IR::Node *postorder(IR::Neq *expr) override;
    const IR::Node *relation(IR::Operation_Relation *expr, bool grt, bool eq);
    const IR::Node *postorder(IR::Geq *expr) override { return relation(expr, true, true); }
    const IR::Node *postorder(IR::Grt *expr) override { return relation(expr, true, false); }
    const IR::Node *postorder(IR::Leq *expr) override { return relation(expr, false, true); }
    const IR::Node *postorder(IR::Lss *expr) override { return relation(expr, false, false); }
    const IR::Node *postorder(IR::BXor *expr) override;
    const IR::Node *postorder(IR::LAnd *expr) override;
    const IR::Node *postorder(IR::LOr *expr) override;
    const IR::Node *postorder(IR::LNot *expr) override;
    const IR::Node *postorder(IR::Sub *expr) override;
    const IR::Node *postorder(IR::SubSat *expr) override;
    const IR::Node *postorder(IR::Add *expr) override;
    const IR::Node *postorder(IR::AddSat *expr) override;
    const IR::Node *postorder(IR::UPlus *expr) override;
    const IR::Node *postorder(IR::Shl *expr) override;
    const IR::Node *postorder(IR::Shr *expr) override;
    const IR::Node *postorder(IR::Mul *expr) override;
    const IR::Node *postorder(IR::Div *expr) override;
    const IR::Node *postorder(IR::Mod *expr) override;
    const IR::Node *postorder(IR::Mux *expr) override;
    const IR::Node *postorder(IR::Slice *expr) override;
    const IR::Node *postorder(IR::PlusSlice *expr) override;
    const IR::Node *postorder(IR::Cast *expr) override;
    const IR::Node *postorder(IR::Mask *expr) override;
    const IR::Node *postorder(IR::Range *expr) override;
    const IR::Node *postorder(IR::Concat *expr) override;
    const IR::Node *postorder(IR::ArrayIndex *expr) override;
 
    const IR::BlockStatement *preorder(IR::BlockStatement *bs) override {
        // FIXME: Do we need to check for expression, so we'd be able to fine tune, e.g.
        // @disable_optimization("strength_reduce")
        if (bs->hasAnnotation(IR::Annotation::disableOptimizationAnnotation)) prune();
        return bs;
    }
};
 
class StrengthReduction : public PassManager {
 public:
    explicit StrengthReduction(TypeMap *typeMap, TypeChecking *typeChecking = nullptr,
                               StrengthReductionPolicy *policy = nullptr) {
        if (typeMap != nullptr) {
            if (!typeChecking) typeChecking = new TypeChecking(nullptr, typeMap, true);
            passes.push_back(typeChecking);
        }
        passes.push_back(new DoStrengthReduction(typeMap, policy));
    }
 
    explicit StrengthReduction(TypeMap *typeMap, StrengthReductionPolicy *policy)
        : StrengthReduction(typeMap, nullptr, policy) {}
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_STRENGTHREDUCTION_H_ */