target.h

#ifndef BACKENDS_P4TOOLS_COMMON_CORE_TARGET_H_
#define BACKENDS_P4TOOLS_COMMON_CORE_TARGET_H_
 
#include <map>
#include <optional>
#include <string>
 
#include "ir/ir.h"
#include "lib/exceptions.h"
 
namespace P4Tools {
 
class Target {
 public:
    struct Spec {
        std::string deviceName;
        std::string archName;
 
        Spec(std::string deviceName, std::string archName);
 
        bool operator<(const Spec &) const;
    };
 
    static bool init(std::string deviceName, std::string archName);
 
    static bool setDevice(std::string deviceName);
 
    static bool setArch(std::string archName);
 
    std::string toolName;
 
    Spec spec;
 
    // A virtual destructor makes this class polymorphic, so that the dynamic cast in get() can
    // work.
    virtual ~Target() = default;
 
    virtual const IR::Expression *createTargetUninitialized(const IR::Type *type,
                                                            bool forceTaint) const;
 
 protected:
    Target(std::string toolName, std::string deviceName, std::string archName);
 
    //
    // Implemented here because of limitations of templates.
    template <class TargetImpl>
    static const TargetImpl &get(const std::string &toolName) {
        if (curTarget == std::nullopt) {
            FATAL_ERROR(
                "Target not initialized. Please provide a target using the --target option.");
        }
 
        const auto &instances = registry.at(*curTarget);
        BUG_CHECK(instances.count(toolName), "Architecture %1% on device %2% not supported for %3%",
                  curTarget->archName, curTarget->deviceName, toolName);
 
        const auto *instance = instances.at(toolName);
        const auto *casted = dynamic_cast<const TargetImpl *>(instance);
        BUG_CHECK(casted, "%1%/%2% implementation for %3% has wrong type", curTarget->deviceName,
                  curTarget->archName, toolName);
        return *casted;
    }
 
 private:
    static std::optional<Spec> curTarget;
 
    static std::map<Spec, std::map<std::string, const Target *>> registry;
 
    static std::map<std::string, std::string> defaultArchByDevice;
 
    static std::map<std::string, std::string> defaultDeviceByArch;
};
 
}  // namespace P4Tools
 
#endif /* BACKENDS_P4TOOLS_COMMON_CORE_TARGET_H_ */