p4tools/common/core/target.h

#ifndef BACKENDS_P4TOOLS_COMMON_CORE_TARGET_H_
#define BACKENDS_P4TOOLS_COMMON_CORE_TARGET_H_
 
#include <cstdlib>
#include <map>
#include <optional>
#include <string>
 
#include "ir/ir.h"
#include "lib/compile_context.h"
#include "lib/exceptions.h"
 
namespace P4::P4Tools {
 
class Target {
 public:
    struct Spec {
        // TODO: Prefix the variables here and in target with "_" to avoid ambiguities.
        std::string deviceName;
        std::string archName;
 
        Spec(std::string_view deviceName, std::string_view archName);
 
        bool operator<(const Spec &) const;
    };
 
    static bool init(std::string_view deviceName, std::string_view archName);
 
    static bool setDevice(std::string_view deviceName);
 
    static bool setArch(std::string_view 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;
 
    static std::optional<ICompileContext *> initializeTarget(std::string_view toolName,
                                                             const std::vector<const char *> &args);
    static std::optional<ICompileContext *> initializeTarget(std::string_view toolName,
                                                             std::string_view target,
                                                             std::string_view arch);
 
 protected:
    Target(std::string_view toolName, const std::string &deviceName, const std::string &archName);
 
    [[nodiscard]] virtual ICompileContext *makeContext() const = 0;
 
    //
    // Implemented here because of limitations of templates.
    template <class TargetImpl>
    static const TargetImpl &get(std::string_view toolName) {
        if (curTarget == std::nullopt) {
            FATAL_ERROR(
                "Target not initialized. Please provide a target using the --target option.");
        }
 
        const auto &instances = registry.at(*curTarget);
        auto instance = instances.find(toolName);
        BUG_CHECK(instance != instances.end(),
                  "Architecture %1% on device %2% not supported for %3%", curTarget->archName,
                  curTarget->deviceName, toolName);
 
        const auto *casted = dynamic_cast<const TargetImpl *>(instance->second);
        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 *, std::less<>>> registry;
 
    static std::map<std::string, std::string, std::less<>> defaultArchByDevice;
 
    static std::map<std::string, std::string, std::less<>> defaultDeviceByArch;
};
 
}  // namespace P4::P4Tools
 
#endif /* BACKENDS_P4TOOLS_COMMON_CORE_TARGET_H_ */