removeReturns.h

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

class HasExits : public Inspector {
 public:
    bool hasExits;
    bool hasReturns;
    HasExits() : hasExits(false), hasReturns(false) { setName("HasExits"); }
 
    void postorder(const IR::ExitStatement *) override { hasExits = true; }
    void postorder(const IR::ReturnStatement *) override { hasReturns = true; }
};

class MoveToElseAfterBranch : public Modifier {
    /* This pass does not use (inherit from) ControlFlowVisitor, even though it is doing
     * control flow analysis, as it turns out to be more efficient to do it directly here
     * by overloading the branching constructs (if/switch/loops) and not cloning the visitor,
     * because we *only* care about statements (not expressions) locally in a block (and
     * not across calls), and we only have one bit of data (hasJumped flag). */

    bool hasJumped = false;

    bool movedToIfBranch = false;
 
    bool preorder(IR::BlockStatement *) override;
    bool moveFromParentTo(const IR::Statement *&child);
    bool preorder(IR::IfStatement *) override;
    bool preorder(IR::SwitchStatement *) override;
    void postorder(IR::LoopStatement *) override;
    bool branch() {
        hasJumped = true;
        // no need to visit children
        return false;
    }
    bool preorder(IR::BreakStatement *) override { return branch(); }
    bool preorder(IR::ContinueStatement *) override { return branch(); }
    bool preorder(IR::ExitStatement *) override { return branch(); }
    bool preorder(IR::ReturnStatement *) override { return branch(); }
    // Only visit statements, skip all expressions
    bool preorder(IR::Expression *) override { return false; }
 
 public:
    MoveToElseAfterBranch() {}
};

class DoRemoveReturns : public Transform {
 protected:
    MinimalNameGenerator nameGen;
    IR::ID returnVar;      // one for each context
    IR::ID returnedValue;  // only for functions that return expressions
    cstring variableName;
    cstring retValName;
 
    std::vector<TernaryBool> stack;
    void push() { stack.push_back(TernaryBool::No); }
    void pop() { stack.pop_back(); }
    void set(TernaryBool r) {
        BUG_CHECK(!stack.empty(), "Empty stack");
        stack.back() = r;
    }
    TernaryBool hasReturned() {
        BUG_CHECK(!stack.empty(), "Empty stack");
        return stack.back();
    }
 
 public:
    explicit DoRemoveReturns(cstring varName = "hasReturned"_cs, cstring retValName = "retval"_cs)
        : variableName(varName), retValName(retValName) {
        visitDagOnce = false;
        setName("DoRemoveReturns");
    }
 
    const IR::Node *preorder(IR::Function *function) override;
    const IR::Node *preorder(IR::BlockStatement *statement) override;
    const IR::Node *preorder(IR::ReturnStatement *statement) override;
    const IR::Node *preorder(IR::ExitStatement *statement) override;
    const IR::Node *preorder(IR::IfStatement *statement) override;
    const IR::Node *preorder(IR::SwitchStatement *statement) override;
 
    const IR::Node *preorder(IR::P4Action *action) override;
    const IR::Node *preorder(IR::P4Control *control) override;
    const IR::Node *preorder(IR::P4Parser *parser) override {
        prune();
        return parser;
    }
 
    const IR::Node *postorder(IR::LoopStatement *loop) override;
    profile_t init_apply(const IR::Node *node) override;
};
 
class RemoveReturns : public PassManager {
 public:
    RemoveReturns() : PassManager({new MoveToElseAfterBranch(), new DoRemoveReturns()}) {}
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_REMOVERETURNS_H_ */