removeParameters.h

/*
 * Copyright 2016 VMware, Inc.
 * SPDX-FileCopyrightText: 2016 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_REMOVEPARAMETERS_H_
#define FRONTENDS_P4_REMOVEPARAMETERS_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
 
namespace P4 {

class ActionInvocation {
    std::map<const IR::P4Action *, const IR::MethodCallExpression *> invocations;
    std::set<const IR::P4Action *> all;  // for these actions remove all parameters
    std::set<const IR::MethodCallExpression *> calls;
    std::map<const IR::MethodCallExpression *, unsigned> defaultActions;
 
 public:
    void bind(const IR::P4Action *action, const IR::MethodCallExpression *invocation,
              bool allParams) {
        CHECK_NULL(action);
        BUG_CHECK(invocations.find(action) == invocations.end(), "%1%: action called twice",
                  action);
        invocations.emplace(action, invocation);
        if (allParams) all.emplace(action);
        calls.emplace(invocation);
    }
    void bindDefaultAction(const IR::P4Action *action,
                           const IR::MethodCallExpression *defaultInvocation) {
        // We must have a binding for this action already.
        auto actionCallInvocation = ::P4::get(invocations, action);
        CHECK_NULL(actionCallInvocation);
        // We must remove all arguments which are bound in the action list.
        unsigned boundArgs = actionCallInvocation->arguments->size();
        defaultActions.emplace(defaultInvocation, boundArgs);
    }
    const IR::MethodCallExpression *get(const IR::P4Action *action) const {
        return ::P4::get(invocations, action);
    }
    bool removeAllParameters(const IR::P4Action *action) const {
        return all.find(action) != all.end();
    }
    bool isCall(const IR::MethodCallExpression *expression) const {
        return calls.find(expression) != calls.end();
    }
    unsigned argsToRemove(const IR::MethodCallExpression *defaultCall) const {
        if (defaultActions.find(defaultCall) == defaultActions.end()) return 0;
        return ::P4::get(defaultActions, defaultCall);
    }
};
 
class FindActionParameters : public Inspector, public ResolutionContext {
    TypeMap *typeMap;
    ActionInvocation *invocations;
 
 public:
    FindActionParameters(TypeMap *typeMap, ActionInvocation *invocations)
        : typeMap(typeMap), invocations(invocations) {
        CHECK_NULL(invocations);
        CHECK_NULL(typeMap);
        setName("FindActionParameters");
    }
 
    void postorder(const IR::ActionListElement *element) override;
    void postorder(const IR::MethodCallExpression *expression) override;
};

class DoRemoveActionParameters : public Transform {
    ActionInvocation *invocations;
    TypeMap *typeMap;
    MinimalNameGenerator *nameGen;
 
 public:
    DoRemoveActionParameters(ActionInvocation *invocations, TypeMap *typeMap,
                             MinimalNameGenerator *nameGen)
        : invocations(invocations), typeMap(typeMap), nameGen(nameGen) {
        CHECK_NULL(invocations);
        CHECK_NULL(typeMap);
        CHECK_NULL(nameGen);
        setName("DoRemoveActionParameters");
    }
 
    const IR::Node *postorder(IR::P4Action *table) override;
    const IR::Node *postorder(IR::ActionListElement *element) override;
    const IR::Node *postorder(IR::MethodCallExpression *expression) override;
    ActionInvocation *getInvocations() { return invocations; }
};
 
class RemoveActionParameters : public PassManager {
 public:
    explicit RemoveActionParameters(TypeMap *typeMap, TypeChecking *typeChecking = nullptr);
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_REMOVEPARAMETERS_H_ */