parameterSubstitution.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_PARAMETERSUBSTITUTION_H_
#define FRONTENDS_P4_PARAMETERSUBSTITUTION_H_
 
#include <iostream>
 
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/enumerator.h"
 
namespace P4 {
 
/* Maps Parameters to Arguments via their name.  Note that
   parameter identity is not important, but the parameter name is. */
class ParameterSubstitution : public IHasDbPrint {
 protected:
    bool containsName(cstring name) const {
        return parameterValues.find(name) != parameterValues.end();
    }
 
 public:
    ParameterSubstitution() = default;
    ParameterSubstitution(const ParameterSubstitution &other) = default;
 
    void add(const IR::Parameter *parameter, const IR::Argument *value);
    const IR::Argument *lookupByName(cstring name) const { return get(parameterValues, name); }
 
    const IR::Argument *lookup(const IR::Parameter *param) const {
        return lookupByName(param->name.name);
    }
 
    bool contains(const IR::Parameter *param) const {
        if (!containsName(param->name.name)) return false;
        return true;
    }
 
    const IR::Parameter *findParameter(const IR::Argument *argument) const {
        for (auto p : *getParametersInOrder())
            if (lookup(p) == argument) return p;
        return nullptr;
    }
 
    bool empty() const { return parameterValues.empty(); }

    // For actions only some parameters may be bound.
    void populate(const IR::ParameterList *params, const IR::Vector<IR::Argument> *args);

    Util::Enumerator<const IR::Parameter *> *getParametersInArgumentOrder() const {
        return Util::enumerate(parameters);
    }

    Util::Enumerator<const IR::Parameter *> *getParametersInOrder() const {
        if (paramList == nullptr) return new Util::EmptyEnumerator<const IR::Parameter *>;
        return paramList->getEnumerator();
    }
 
    void dbprint(std::ostream &out) const override {
        bool brief = (DBPrint::dbgetflags(out) & DBPrint::Brief);
        if (paramList != nullptr) {
            if (!brief) out << "paramList:" << Log::endl;
            for (auto s : *paramList->getEnumerator()) {
                out << dbp(s) << "=>" << dbp(lookup(s));
                if (!brief) out << " " << lookup(s);
                out << Log::endl;
            }
        } else {
            if (!brief) out << "parametersByName:" << Log::endl;
            for (auto s : parametersByName) {
                out << dbp(s.second) << "=>" << dbp(lookupByName(s.first));
                if (!brief) out << " " << lookupByName(s.first);
                out << Log::endl;
            }
        }
    }
 
 private:
    // Parameter names are unique for a procedure, so each name
    // should show up only once.
    absl::flat_hash_map<cstring, const IR::Argument *> parameterValues;
    absl::flat_hash_map<cstring, const IR::Parameter *> parametersByName;
    std::vector<const IR::Parameter *> parameters;
    const IR::ParameterList *paramList = nullptr;
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_PARAMETERSUBSTITUTION_H_ */