scope.h

#ifndef BACKENDS_P4TOOLS_MODULES_SMITH_COMMON_SCOPE_H_
#define BACKENDS_P4TOOLS_MODULES_SMITH_COMMON_SCOPE_H_
 
#include <cstddef>
#include <map>
#include <optional>
#include <set>
#include <vector>
 
#include "ir/ir.h"
#include "ir/node.h"
#include "ir/vector.h"
#include "lib/cstring.h"
 
namespace P4::P4Tools::P4Smith {
 
struct Requirements {
    bool require_scalar{false};
    bool compile_time_known{false};
    bool no_methodcalls{false};
    bool not_zero{false};
    bool not_negative{false};
    bool byte_align_headers{false};
    int shift_width{8};
    Requirements()
 
        = default;
};
 
struct Constraints {
    bool const_header_stack_index{false};
    bool const_lshift_count{false};
    bool single_stage_actions{false};
    int max_phv_container_width{0};
    // This is the maximum bitwidth that
    // can be specified for different targets.
    int max_bitwidth{128};
    Constraints()
 
        = default;
};
 
struct Properties {
    bool width_unknown{false};
    bool has_methodcall{false};
    bool in_action{false};
    size_t depth = 0;
    // This means we are in a block that returns.
    // We need to return an expression with the specified type.
    const IR::Type *ret_type = nullptr;
    Properties() = default;
};
 
class P4Scope {
 public:
    static std::vector<IR::Vector<IR::Node> *> scope;
 
    static std::set<cstring> usedNames;
 
    static std::map<cstring, std::map<int, std::set<cstring>>> lvalMap;
 
    static std::map<cstring, std::map<int, std::set<cstring>>> lvalMapRw;
 
    static std::set<const IR::P4Table *> callableTables;
 
    static std::set<cstring> notInitializedStructs;
 
    static Properties prop;
 
    static Requirements req;
 
    static Constraints constraints;
 
    P4Scope() = default;
 
    ~P4Scope() = default;
 
    static void addToScope(const IR::Node *n);
    static void startLocalScope();
    static void endLocalScope();
 
    static void addLval(const IR::Type *tp, cstring name, bool read_only = false);
    static bool checkLval(const IR::Type *tp, bool must_write = false);
    static cstring pickLval(const IR::Type *tp, bool must_write = false);
    static void deleteLval(const IR::Type *tp, cstring name);
    static std::set<cstring> getCandidateLvals(const IR::Type *tp, bool must_write = true);
    static bool hasWriteableLval(cstring typeKey);
    static std::optional<std::map<int, std::set<cstring>>> getWriteableLvalForTypeKey(
        cstring typeKey);
 
    static const IR::Type_Bits *pickDeclaredBitType(bool must_write = false);
 
    static const IR::Type_Declaration *getTypeByName(cstring name);
 
    // template to get all declarations
    // C++ is so shit... templates must be inlined to be generally usable.
    template <typename T>
    static std::vector<const T *> getDecls() {
        std::vector<const T *> ret;
 
        for (auto *subScope : scope) {
            for (const auto *node : *subScope) {
                if (const T *tmpObj = node->to<T>()) {
                    ret.push_back(tmpObj);
                }
            }
        }
        return ret;
    }
 
    static std::vector<const IR::Type_Declaration *> getFilteredDecls(std::set<cstring> filter);
    static std::set<const IR::P4Table *> *getCallableTables();
};
}  // namespace P4::P4Tools::P4Smith
 
#endif /* BACKENDS_P4TOOLS_MODULES_SMITH_COMMON_SCOPE_H_ */