actionSynthesis.h

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

class ActionSynthesisPolicy {
 public:
    virtual ~ActionSynthesisPolicy() {}
    virtual bool convert(const Visitor::Context *ctxt, const IR::P4Control *control) = 0;

    virtual bool can_combine(const Visitor::Context *, const IR::BlockStatement *,
                             const IR::StatOrDecl *) {
        return true;
    }
};

class DoMoveActionsToTables : public Transform {
    ReferenceMap *refMap;
    TypeMap *typeMap;
    std::vector<const IR::P4Table *> tables;  // inserted tables
 
 public:
    DoMoveActionsToTables(ReferenceMap *refMap, TypeMap *typeMap)
        : refMap(refMap), typeMap(typeMap) {
        CHECK_NULL(refMap);
        CHECK_NULL(typeMap);
        setName("DoMoveActionsToTables");
    }
    const IR::Node *preorder(IR::P4Parser *parser) override {
        prune();
        return parser;
    }
    const IR::Node *postorder(IR::P4Control *control) override;
    const IR::Node *preorder(IR::P4Control *control) override {
        tables.clear();
        return control;
    }
    const IR::Node *preorder(IR::P4Action *action) override {
        prune();
        return action;
    }
    const IR::Node *postorder(IR::MethodCallStatement *statement) override;
};

class DoSynthesizeActions : public Transform {
    ReferenceMap *refMap;
    TypeMap *typeMap;
    std::vector<const IR::P4Action *> actions;  // inserted actions
    bool changes = false;
    ActionSynthesisPolicy *policy;
 
 public:
    // If true the statement must be moved to an action
    bool mustMove(const IR::MethodCallStatement *statement);
    bool mustMove(const IR::BaseAssignmentStatement *statement);
 
    DoSynthesizeActions(ReferenceMap *refMap, TypeMap *typeMap, ActionSynthesisPolicy *policy)
        : refMap(refMap), typeMap(typeMap), policy(policy) {
        CHECK_NULL(refMap);
        CHECK_NULL(typeMap);
        setName("DoSynthesizeActions");
    }
    const IR::Node *preorder(IR::P4Parser *parser) override {
        prune();
        return parser;
    }
    const IR::Node *postorder(IR::P4Control *control) override;
    const IR::Node *preorder(IR::P4Control *control) override;
    const IR::Node *preorder(IR::P4Action *action) override {
        prune();
        return action;
    }  // skip actions
    // We do not handle return: this pass should be called after it has been removed
    const IR::Node *preorder(IR::BlockStatement *statement) override;
    const IR::Node *preorder(IR::BaseAssignmentStatement *statement) override;
    const IR::Node *preorder(IR::MethodCallStatement *statement) override;
    const IR::Node *preorder(IR::ExitStatement *statement) override;
    const IR::Node *preorder(IR::Function *function) override {
        prune();
        return function;
    }
 
 protected:
    const IR::Statement *createAction(const IR::Statement *body);
};
 
class SynthesizeActions : public PassManager {
 public:
    SynthesizeActions(ReferenceMap *refMap, TypeMap *typeMap,
                      ActionSynthesisPolicy *policy = nullptr,
                      TypeChecking *typeChecking = nullptr) {
        if (!typeChecking) typeChecking = new TypeChecking(refMap, typeMap);
        passes.push_back(typeChecking);
        passes.push_back(new DoSynthesizeActions(refMap, typeMap, policy));
        setName("SynthesizeActions");
    }
};
 
class MoveActionsToTables : public PassManager {
 public:
    MoveActionsToTables(ReferenceMap *refMap, TypeMap *typeMap,
                        TypeChecking *typeChecking = nullptr) {
        if (!typeChecking) typeChecking = new TypeChecking(refMap, typeMap);
        passes.push_back(typeChecking);
        passes.push_back(new DoMoveActionsToTables(refMap, typeMap));
        setName("MoveActionsToTables");
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_ACTIONSYNTHESIS_H_ */