backends/common/programStructure.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_COMMON_PROGRAMSTRUCTURE_H_
#define BACKENDS_COMMON_PROGRAMSTRUCTURE_H_
 
#include "backends/common/metermap.h"
#include "ir/ir.h"
#include "ir/visitor.h"
#include "lib/ordered_map.h"
#include "lib/ordered_set.h"
 
namespace P4 {
 
using ResourceMap = ordered_map<const IR::Node *, const IR::CompileTimeValue *>;

class ProgramStructure {
 public:
    ordered_map<const IR::P4Action *, const IR::P4Control *> actions;
    ordered_map<const IR::Parameter *, unsigned> index;
    ordered_set<const IR::Parameter *> nonActionParameters;
    ordered_map<const IR::P4Action *, unsigned> ids;
    std::vector<const IR::Declaration_Variable *> variables;
    ordered_map<const IR::IDeclaration *, unsigned int> errorCodesMap;
    DirectMeterMap directMeterMap;
    ordered_map<cstring, const IR::P4Table *> directCounterMap;
    ordered_map<const IR::StructField *, cstring> scalarMetadataFields;
    std::set<cstring> match_kinds;
    ResourceMap resourceMap;
 
    ProgramStructure() {}
};
 
class DiscoverStructure : public Inspector {
 public:
    ProgramStructure *structure;
 
    explicit DiscoverStructure(ProgramStructure *structure) : structure(structure) {
        setName("DiscoverStructure");
    }
    void postorder(const IR::ParameterList *paramList) override;
    void postorder(const IR::P4Action *action) override;
    void postorder(const IR::Declaration_Variable *decl) override;
    void postorder(const IR::Type_Error *errors) override;
    void postorder(const IR::Declaration_MatchKind *kind) override;
};

class BuildResourceMap : public Inspector {
    ResourceMap *resourceMap;
 
 public:
    explicit BuildResourceMap(ResourceMap *resourceMap) : resourceMap(resourceMap) {
        CHECK_NULL(resourceMap);
    }
 
    bool preorder(const IR::ControlBlock *control) override {
        resourceMap->emplace(control->container, control);
        for (auto cv : control->constantValue) {
            resourceMap->emplace(cv.first, cv.second);
        }
 
        for (const auto *c : control->container->controlLocals) {
            if (c->is<IR::InstantiatedBlock>()) {
                resourceMap->emplace(c, control->getValue(c));
            }
        }
        return false;
    }
 
    bool preorder(const IR::ParserBlock *parser) override {
        resourceMap->emplace(parser->container, parser);
        for (auto cv : parser->constantValue) {
            resourceMap->emplace(cv.first, cv.second);
            if (cv.second->is<IR::Block>()) {
                visit(cv.second->getNode());
            }
        }
 
        for (const auto *c : parser->container->parserLocals) {
            if (c->is<IR::InstantiatedBlock>()) {
                resourceMap->emplace(c, parser->getValue(c));
            }
        }
        return false;
    }
 
    bool preorder(const IR::TableBlock *table) override {
        resourceMap->emplace(table->container, table);
        for (auto cv : table->constantValue) {
            resourceMap->emplace(cv.first, cv.second);
            if (cv.second->is<IR::Block>()) {
                visit(cv.second->getNode());
            }
        }
        return false;
    }
 
    bool preorder(const IR::PackageBlock *package) override {
        for (auto cv : package->constantValue) {
            if (cv.second->is<IR::Block>()) {
                visit(cv.second->getNode());
            }
        }
        return false;
    }
 
    bool preorder(const IR::ToplevelBlock *tlb) override {
        const auto *package = tlb->getMain();
        visit(package);
        return false;
    }
};
 
}  // namespace P4
 
#endif /* BACKENDS_COMMON_PROGRAMSTRUCTURE_H_ */