expression.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_BMV2_COMMON_EXPRESSION_H_
#define BACKENDS_BMV2_COMMON_EXPRESSION_H_
 
#include "backends/common/programStructure.h"
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/coreLibrary.h"
#include "frontends/p4/enumInstance.h"
#include "frontends/p4/methodInstance.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
#include "lib/big_int_util.h"
#include "lib/json.h"
#include "lower.h"
 
namespace P4::BMV2 {

class ArithmeticFixup : public Transform {
    P4::TypeMap *typeMap;
 
 public:
    const IR::Expression *fix(const IR::Expression *expr, const IR::Type_Bits *type);
    const IR::Node *updateType(const IR::Expression *expression);
    const IR::Node *postorder(IR::Expression *expression) override;
    const IR::Node *postorder(IR::Operation_Binary *expression) override;
    const IR::Node *postorder(IR::Neg *expression) override;
    const IR::Node *postorder(IR::Cmpl *expression) override;
    const IR::Node *postorder(IR::Cast *expression) override;
    explicit ArithmeticFixup(P4::TypeMap *typeMap) : typeMap(typeMap) { CHECK_NULL(typeMap); }
};
 
class ExpressionConverter : public Inspector {
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    P4::ProgramStructure *structure;
    P4::P4CoreLibrary &corelib;
    cstring scalarsName;

    std::map<const IR::Expression *, Util::IJson *> map;
    bool leftValue;  // true if converting a left value
    // in some cases the bmv2 JSON requires a 'bitwidth' attribute for hex
    // strings (e.g. for constants in calculation inputs). When this flag is set
    // to true, we add this attribute.
    bool withConstantWidths{false};
 
 public:
    ExpressionConverter(P4::ReferenceMap *refMap, P4::TypeMap *typeMap,
                        P4::ProgramStructure *structure, cstring scalarsName)
        : refMap(refMap),
          typeMap(typeMap),
          structure(structure),
          corelib(P4::P4CoreLibrary::instance()),
          scalarsName(scalarsName),
          leftValue(false),
          simpleExpressionsOnly(false) {}
    bool simpleExpressionsOnly;

    const IR::Parameter *enclosingParamReference(const IR::Expression *expression);

    virtual Util::IJson *convertParam(const IR::Parameter *param, cstring fieldName) = 0;
 
    Util::IJson *get(const IR::Expression *expression) const;
    Util::IJson *fixLocal(Util::IJson *json);

    Util::IJson *convert(const IR::Expression *e, bool doFixup = true, bool wrap = true,
                         bool convertBool = false);
    Util::IJson *convertLeftValue(const IR::Expression *e);
    Util::IJson *convertWithConstantWidths(const IR::Expression *e);
    bool isArrayIndexRuntime(const IR::Expression *e);
 
    void postorder(const IR::BoolLiteral *expression) override;
    void postorder(const IR::MethodCallExpression *expression) override;
    void postorder(const IR::Cast *expression) override;
    void postorder(const IR::Slice *expression) override;
    void postorder(const IR::AddSat *expression) override { saturated_binary(expression); }
    void postorder(const IR::SubSat *expression) override { saturated_binary(expression); }
    void postorder(const IR::Constant *expression) override;
    void postorder(const IR::ArrayIndex *expression) override;
    void postorder(const IR::Member *expression) override;
    void postorder(const IR::Mux *expression) override;
    void postorder(const IR::IntMod *expression) override;
    void postorder(const IR::Operation_Binary *expression) override;
    void postorder(const IR::ListExpression *expression) override;
    void postorder(const IR::StructExpression *expression) override;
    void postorder(const IR::Operation_Unary *expression) override;
    void postorder(const IR::PathExpression *expression) override;
    void postorder(const IR::StringLiteral *expression) override;
    void postorder(const IR::TypeNameExpression *expression) override;
    void postorder(const IR::Expression *expression) override;
    void mapExpression(const IR::Expression *expression, Util::IJson *json);
 
 private:
    void binary(const IR::Operation_Binary *expression);
    void saturated_binary(const IR::Operation_Binary *expression);
};
 
}  // namespace P4::BMV2
 
#endif /* BACKENDS_BMV2_COMMON_EXPRESSION_H_ */