removeComplexExpressions.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef MIDEND_REMOVECOMPLEXEXPRESSIONS_H_
#define MIDEND_REMOVECOMPLEXEXPRESSIONS_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
 
namespace P4 {

class RemoveComplexExpressionsPolicy {
 public:
    virtual ~RemoveComplexExpressionsPolicy() {}
    virtual bool convert(const IR::P4Control *control) const = 0;
};

class RemoveComplexExpressions : public Transform, public ResolutionContext {
 public:
    MinimalNameGenerator nameGen;
    P4::TypeMap *typeMap;
    RemoveComplexExpressionsPolicy *policy;
    IR::IndexedVector<IR::Declaration> newDecls;
    IR::IndexedVector<IR::StatOrDecl> assignments;
 
    explicit RemoveComplexExpressions(P4::TypeMap *typeMap,
                                      RemoveComplexExpressionsPolicy *policy = nullptr)
        : typeMap(typeMap), policy(policy) {
        CHECK_NULL(typeMap);
        setName("RemoveComplexExpressions");
    }
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = Transform::init_apply(node);
        node->apply(nameGen);
 
        return rv;
    }
 
    const IR::PathExpression *createTemporary(const IR::Expression *expression);
    const IR::Expression *simplifyExpression(const IR::Expression *expression, bool force);
    const IR::Vector<IR::Expression> *simplifyExpressions(const IR::Vector<IR::Expression> *vec,
                                                          bool force = false);
    const IR::Vector<IR::Argument> *simplifyExpressions(const IR::Vector<IR::Argument> *vec);
    const IR::IndexedVector<IR::NamedExpression> *simplifyExpressions(
        const IR::IndexedVector<IR::NamedExpression> *vec);
 
    const IR::Node *simpleStatement(IR::Statement *statement);
 
    const IR::Node *postorder(IR::SelectExpression *expression) override;
    const IR::Node *preorder(IR::ParserState *state) override {
        assignments.clear();
        return state;
    }
    const IR::Node *postorder(IR::ParserState *state) override {
        state->components.append(assignments);
        return state;
    }
    const IR::Node *postorder(IR::MethodCallExpression *expression) override;
    const IR::Node *preorder(IR::P4Parser *parser) override {
        newDecls.clear();
        return parser;
    }
    const IR::Node *postorder(IR::P4Parser *parser) override {
        if (newDecls.size() != 0) {
            // prepend declarations
            newDecls.append(parser->parserLocals);
            parser->parserLocals = newDecls;
        }
        return parser;
    }
    const IR::Node *preorder(IR::P4Control *control) override;
    const IR::Node *postorder(IR::P4Control *control) override {
        if (newDecls.size() != 0) {
            // prepend declarations
            newDecls.append(control->controlLocals);
            control->controlLocals = newDecls;
        }
        return control;
    }
    const IR::Node *postorder(IR::Statement *statement) override;
    const IR::Node *postorder(IR::MethodCallStatement *statement) override;
};
 
}  // namespace P4
 
#endif /* MIDEND_REMOVECOMPLEXEXPRESSIONS_H_ */