actionSynthesis.h

/*
Copyright 2013-present Barefoot Networks, Inc.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#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::AssignmentStatement *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::AssignmentStatement *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_ */