p4tools/common/core/target.h

/*
 * SPDX-FileCopyrightText: 2022 The P4 Language Consortium
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#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<std::unique_ptr<ICompileContext>> initializeTarget(
        std::string_view toolName, const std::vector<const char *> &args);
    static std::optional<std::unique_ptr<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_ */