moveDeclarations.h

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

class MoveDeclarations : public Transform {
    bool parsersOnly;

    // FIXME: Do we really need IR::Vector here?
    std::vector<IR::Vector<IR::Declaration>> toMove;
    void push() { toMove.emplace_back(); }
    void pop() {
        BUG_CHECK(!toMove.empty(), "Empty move stack");
        toMove.pop_back();
    }
    const IR::Vector<IR::Declaration> &getMoves() const {
        BUG_CHECK(!toMove.empty(), "Empty move stack");
        return toMove.back();
    }
    IR::Vector<IR::Declaration> &getMoves() {
        BUG_CHECK(!toMove.empty(), "Empty move stack");
        return toMove.back();
    }
    void addMove(const IR::Declaration *decl) { getMoves().push_back(decl); }
 
 public:
    explicit MoveDeclarations(bool parsersOnly = false) : parsersOnly(parsersOnly) {
        setName("MoveDeclarations");
        visitDagOnce = false;
    }
    void end_apply(const IR::Node *) override { BUG_CHECK(toMove.empty(), "Non empty move stack"); }
    const IR::Node *preorder(IR::P4Action *action) override {
        if (parsersOnly) {
            prune();
            return action;
        }
        if (!isInContext<IR::P4Control>())
            // If we are not in a control, move to the beginning of the action.
            // Otherwise move to the control's beginning.
            push();
        return action;
    }
    const IR::Node *preorder(IR::P4Control *control) override {
        if (parsersOnly) {
            prune();
            return control;
        }
        push();
        return control;
    }
    const IR::Node *preorder(IR::P4Parser *parser) override {
        push();
        return parser;
    }
    const IR::Node *preorder(IR::Function *function) override {
        if (parsersOnly) {
            prune();
            return function;
        }
        push();
        return function;
    }
    const IR::Node *postorder(IR::P4Action *action) override;
    const IR::Node *postorder(IR::P4Control *control) override;
    const IR::Node *postorder(IR::P4Parser *parser) override;
    const IR::Node *postorder(IR::Function *function) override;
    const IR::Node *postorder(IR::Declaration_Variable *decl) override;
    const IR::Node *postorder(IR::Declaration_Constant *decl) override;
};

class MoveInitializers : public Transform, public ResolutionContext {
    MinimalNameGenerator nameGen;
    IR::IndexedVector<IR::StatOrDecl> toMove;  // This contains just IR::AssignmentStatement
    const IR::ParserState *oldStart;  // nullptr if we do not want to rename the start state
    cstring newStartName;             // name allocated to the new start state
    bool loopsBackToStart;            // true if start is reachable from any other state
 
 public:
    MoveInitializers() : newStartName("") { setName("MoveInitializers"); }
    profile_t init_apply(const IR::Node *node) override;
    const IR::Node *preorder(IR::P4Parser *parser) override;
    const IR::Node *preorder(IR::Declaration_Variable *decl) override;
    const IR::Node *postorder(IR::ParserState *state) override;
    const IR::Node *postorder(IR::Path *path) override;
    const IR::Node *postorder(IR::P4Parser *parser) override;
    const IR::Node *postorder(IR::P4Control *control) override;
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_MOVEDECLARATIONS_H_ */