Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- MC/TargetRegistry.h - Target Registration ----------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file exposes the TargetRegistry interface, which tools can use to access

// the appropriate target specific classes (TargetMachine, AsmPrinter, etc.)

// which have been registered.

//

// Target specific class implementations should register themselves using the

// appropriate TargetRegistry interfaces.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_MC_TARGETREGISTRY_H

#define LLVM_MC_TARGETREGISTRY_H

#include "llvm-c/DisassemblerTypes.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/Triple.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/MC/MCObjectFileInfo.h"

#include "llvm/Support/CodeGen.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/FormattedStream.h"

#include <cassert>

#include <cstddef>

#include <iterator>

#include <memory>

#include <optional>

#include <string>

namespace llvm {

class AsmPrinter;

class MCAsmBackend;

class MCAsmInfo;

class MCAsmParser;

class MCCodeEmitter;

class MCContext;

class MCDisassembler;

class MCInstPrinter;

class MCInstrAnalysis;

class MCInstrInfo;

class MCObjectWriter;

class MCRegisterInfo;

class MCRelocationInfo;

class MCStreamer;

class MCSubtargetInfo;

class MCSymbolizer;

class MCTargetAsmParser;

class MCTargetOptions;

class MCTargetStreamer;

class raw_ostream;

class TargetMachine;

class TargetOptions;

namespace mca {

class CustomBehaviour;

class InstrPostProcess;

class InstrumentManager;

struct SourceMgr;

} // namespace mca

MCStreamer *createNullStreamer(MCContext &Ctx);

// Takes ownership of \p TAB and \p CE.

/// Create a machine code streamer which will print out assembly for the native

/// target, suitable for compiling with a native assembler.

///

/// \param InstPrint - If given, the instruction printer to use. If not given

/// the MCInst representation will be printed.  This method takes ownership of

/// InstPrint.

///

/// \param CE - If given, a code emitter to use to show the instruction

/// encoding inline with the assembly. This method takes ownership of \p CE.

///

/// \param TAB - If given, a target asm backend to use to show the fixup

/// information in conjunction with encoding information. This method takes

/// ownership of \p TAB.

///

/// \param ShowInst - Whether to show the MCInst representation inline with

/// the assembly.

MCStreamer *

createAsmStreamer(MCContext &Ctx, std::unique_ptr<formatted_raw_ostream> OS,

                  bool isVerboseAsm, bool useDwarfDirectory,

                  MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,

                  std::unique_ptr<MCAsmBackend> &&TAB, bool ShowInst);

MCStreamer *createELFStreamer(MCContext &Ctx,

                              std::unique_ptr<MCAsmBackend> &&TAB,

                              std::unique_ptr<MCObjectWriter> &&OW,

                              std::unique_ptr<MCCodeEmitter> &&CE,

                              bool RelaxAll);

MCStreamer *createMachOStreamer(MCContext &Ctx,

                                std::unique_ptr<MCAsmBackend> &&TAB,

                                std::unique_ptr<MCObjectWriter> &&OW,

                                std::unique_ptr<MCCodeEmitter> &&CE,

                                bool RelaxAll, bool DWARFMustBeAtTheEnd,

                                bool LabelSections = false);

MCStreamer *createWasmStreamer(MCContext &Ctx,

                               std::unique_ptr<MCAsmBackend> &&TAB,

                               std::unique_ptr<MCObjectWriter> &&OW,

                               std::unique_ptr<MCCodeEmitter> &&CE,

                               bool RelaxAll);

MCStreamer *createXCOFFStreamer(MCContext &Ctx,

                                std::unique_ptr<MCAsmBackend> &&TAB,

                                std::unique_ptr<MCObjectWriter> &&OW,

                                std::unique_ptr<MCCodeEmitter> &&CE,

                                bool RelaxAll);

MCStreamer *createSPIRVStreamer(MCContext &Ctx,

                                std::unique_ptr<MCAsmBackend> &&TAB,

                                std::unique_ptr<MCObjectWriter> &&OW,

                                std::unique_ptr<MCCodeEmitter> &&CE,

                                bool RelaxAll);

MCStreamer *createDXContainerStreamer(MCContext &Ctx,

                                      std::unique_ptr<MCAsmBackend> &&TAB,

                                      std::unique_ptr<MCObjectWriter> &&OW,

                                      std::unique_ptr<MCCodeEmitter> &&CE,

                                      bool RelaxAll);

MCRelocationInfo *createMCRelocationInfo(const Triple &TT, MCContext &Ctx);

MCSymbolizer *createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo,

                                 LLVMSymbolLookupCallback SymbolLookUp,

                                 void *DisInfo, MCContext *Ctx,

                                 std::unique_ptr<MCRelocationInfo> &&RelInfo);

mca::CustomBehaviour *createCustomBehaviour(const MCSubtargetInfo &STI,

                                            const mca::SourceMgr &SrcMgr,

                                            const MCInstrInfo &MCII);

mca::InstrPostProcess *createInstrPostProcess(const MCSubtargetInfo &STI,

                                              const MCInstrInfo &MCII);

mca::InstrumentManager *createInstrumentManager(const MCSubtargetInfo &STI,

                                                const MCInstrInfo &MCII);

/// Target - Wrapper for Target specific information.

///

/// For registration purposes, this is a POD type so that targets can be

/// registered without the use of static constructors.

///

/// Targets should implement a single global instance of this class (which

/// will be zero initialized), and pass that instance to the TargetRegistry as

/// part of their initialization.

class Target {

public:

  friend struct TargetRegistry;

  using ArchMatchFnTy = bool (*)(Triple::ArchType Arch);

  using MCAsmInfoCtorFnTy = MCAsmInfo *(*)(const MCRegisterInfo &MRI,

                                           const Triple &TT,

                                           const MCTargetOptions &Options);

  using MCObjectFileInfoCtorFnTy = MCObjectFileInfo *(*)(MCContext &Ctx,

                                                         bool PIC,

                                                         bool LargeCodeModel);

  using MCInstrInfoCtorFnTy = MCInstrInfo *(*)();

  using MCInstrAnalysisCtorFnTy = MCInstrAnalysis *(*)(const MCInstrInfo *Info);

  using MCRegInfoCtorFnTy = MCRegisterInfo *(*)(const Triple &TT);

  using MCSubtargetInfoCtorFnTy = MCSubtargetInfo *(*)(const Triple &TT,

                                                       StringRef CPU,

                                                       StringRef Features);

  using TargetMachineCtorTy = TargetMachine

      *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features,

           const TargetOptions &Options, std::optional<Reloc::Model> RM,

           std::optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT);

  // If it weren't for layering issues (this header is in llvm/Support, but

  // depends on MC?) this should take the Streamer by value rather than rvalue

  // reference.

  using AsmPrinterCtorTy = AsmPrinter *(*)(

      TargetMachine &TM, std::unique_ptr<MCStreamer> &&Streamer);

  using MCAsmBackendCtorTy = MCAsmBackend *(*)(const Target &T,

                                               const MCSubtargetInfo &STI,

                                               const MCRegisterInfo &MRI,

                                               const MCTargetOptions &Options);

  using MCAsmParserCtorTy = MCTargetAsmParser *(*)(

      const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII,

      const MCTargetOptions &Options);

  using MCDisassemblerCtorTy = MCDisassembler *(*)(const Target &T,

                                                   const MCSubtargetInfo &STI,

                                                   MCContext &Ctx);

  using MCInstPrinterCtorTy = MCInstPrinter *(*)(const Triple &T,

                                                 unsigned SyntaxVariant,

                                                 const MCAsmInfo &MAI,

                                                 const MCInstrInfo &MII,

                                                 const MCRegisterInfo &MRI);

  using MCCodeEmitterCtorTy = MCCodeEmitter *(*)(const MCInstrInfo &II,

                                                 MCContext &Ctx);

  using ELFStreamerCtorTy =

      MCStreamer *(*)(const Triple &T, MCContext &Ctx,

                      std::unique_ptr<MCAsmBackend> &&TAB,

                      std::unique_ptr<MCObjectWriter> &&OW,

                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);

  using MachOStreamerCtorTy =

      MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,

                      std::unique_ptr<MCObjectWriter> &&OW,

                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,

                      bool DWARFMustBeAtTheEnd);

  using COFFStreamerCtorTy =

      MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,

                      std::unique_ptr<MCObjectWriter> &&OW,

                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,

                      bool IncrementalLinkerCompatible);

  using WasmStreamerCtorTy =

      MCStreamer *(*)(const Triple &T, MCContext &Ctx,

                      std::unique_ptr<MCAsmBackend> &&TAB,

                      std::unique_ptr<MCObjectWriter> &&OW,

                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);

  using XCOFFStreamerCtorTy =

      MCStreamer *(*)(const Triple &T, MCContext &Ctx,

                      std::unique_ptr<MCAsmBackend> &&TAB,

                      std::unique_ptr<MCObjectWriter> &&OW,

                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);

  using SPIRVStreamerCtorTy =

      MCStreamer *(*)(const Triple &T, MCContext &Ctx,

                      std::unique_ptr<MCAsmBackend> &&TAB,

                      std::unique_ptr<MCObjectWriter> &&OW,

                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);

  using DXContainerStreamerCtorTy =

      MCStreamer *(*)(const Triple &T, MCContext &Ctx,

                      std::unique_ptr<MCAsmBackend> &&TAB,

                      std::unique_ptr<MCObjectWriter> &&OW,

                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);

  using NullTargetStreamerCtorTy = MCTargetStreamer *(*)(MCStreamer &S);

  using AsmTargetStreamerCtorTy = MCTargetStreamer *(*)(

      MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,

      bool IsVerboseAsm);

  using ObjectTargetStreamerCtorTy = MCTargetStreamer *(*)(

      MCStreamer &S, const MCSubtargetInfo &STI);

  using MCRelocationInfoCtorTy = MCRelocationInfo *(*)(const Triple &TT,

                                                       MCContext &Ctx);

  using MCSymbolizerCtorTy = MCSymbolizer *(*)(

      const Triple &TT, LLVMOpInfoCallback GetOpInfo,

      LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx,

      std::unique_ptr<MCRelocationInfo> &&RelInfo);

  using CustomBehaviourCtorTy =

      mca::CustomBehaviour *(*)(const MCSubtargetInfo &STI,

                                const mca::SourceMgr &SrcMgr,

                                const MCInstrInfo &MCII);

  using InstrPostProcessCtorTy =

      mca::InstrPostProcess *(*)(const MCSubtargetInfo &STI,

                                 const MCInstrInfo &MCII);

  using InstrumentManagerCtorTy =

      mca::InstrumentManager *(*)(const MCSubtargetInfo &STI,

                                  const MCInstrInfo &MCII);

private:

  /// Next - The next registered target in the linked list, maintained by the

  /// TargetRegistry.

  Target *Next;

  /// The target function for checking if an architecture is supported.

  ArchMatchFnTy ArchMatchFn;

  /// Name - The target name.

  const char *Name;

  /// ShortDesc - A short description of the target.

  const char *ShortDesc;

  /// BackendName - The name of the backend implementation. This must match the

  /// name of the 'def X : Target ...' in TableGen.

  const char *BackendName;

  /// HasJIT - Whether this target supports the JIT.

  bool HasJIT;

  /// MCAsmInfoCtorFn - Constructor function for this target's MCAsmInfo, if

  /// registered.

  MCAsmInfoCtorFnTy MCAsmInfoCtorFn;

  /// Constructor function for this target's MCObjectFileInfo, if registered.

  MCObjectFileInfoCtorFnTy MCObjectFileInfoCtorFn;

  /// MCInstrInfoCtorFn - Constructor function for this target's MCInstrInfo,

  /// if registered.

  MCInstrInfoCtorFnTy MCInstrInfoCtorFn;

  /// MCInstrAnalysisCtorFn - Constructor function for this target's

  /// MCInstrAnalysis, if registered.

  MCInstrAnalysisCtorFnTy MCInstrAnalysisCtorFn;

  /// MCRegInfoCtorFn - Constructor function for this target's MCRegisterInfo,

  /// if registered.

  MCRegInfoCtorFnTy MCRegInfoCtorFn;

  /// MCSubtargetInfoCtorFn - Constructor function for this target's

  /// MCSubtargetInfo, if registered.

  MCSubtargetInfoCtorFnTy MCSubtargetInfoCtorFn;

  /// TargetMachineCtorFn - Construction function for this target's

  /// TargetMachine, if registered.

  TargetMachineCtorTy TargetMachineCtorFn;

  /// MCAsmBackendCtorFn - Construction function for this target's

  /// MCAsmBackend, if registered.

  MCAsmBackendCtorTy MCAsmBackendCtorFn;

  /// MCAsmParserCtorFn - Construction function for this target's

  /// MCTargetAsmParser, if registered.

  MCAsmParserCtorTy MCAsmParserCtorFn;

  /// AsmPrinterCtorFn - Construction function for this target's AsmPrinter,

  /// if registered.

  AsmPrinterCtorTy AsmPrinterCtorFn;

  /// MCDisassemblerCtorFn - Construction function for this target's

  /// MCDisassembler, if registered.

  MCDisassemblerCtorTy MCDisassemblerCtorFn;

  /// MCInstPrinterCtorFn - Construction function for this target's

  /// MCInstPrinter, if registered.

  MCInstPrinterCtorTy MCInstPrinterCtorFn;

  /// MCCodeEmitterCtorFn - Construction function for this target's

  /// CodeEmitter, if registered.

  MCCodeEmitterCtorTy MCCodeEmitterCtorFn;

  // Construction functions for the various object formats, if registered.

  COFFStreamerCtorTy COFFStreamerCtorFn = nullptr;

  MachOStreamerCtorTy MachOStreamerCtorFn = nullptr;

  ELFStreamerCtorTy ELFStreamerCtorFn = nullptr;

  WasmStreamerCtorTy WasmStreamerCtorFn = nullptr;

  XCOFFStreamerCtorTy XCOFFStreamerCtorFn = nullptr;

  SPIRVStreamerCtorTy SPIRVStreamerCtorFn = nullptr;

  DXContainerStreamerCtorTy DXContainerStreamerCtorFn = nullptr;

  /// Construction function for this target's null TargetStreamer, if

  /// registered (default = nullptr).

  NullTargetStreamerCtorTy NullTargetStreamerCtorFn = nullptr;

  /// Construction function for this target's asm TargetStreamer, if

  /// registered (default = nullptr).

  AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn = nullptr;

  /// Construction function for this target's obj TargetStreamer, if

  /// registered (default = nullptr).

  ObjectTargetStreamerCtorTy ObjectTargetStreamerCtorFn = nullptr;

  /// MCRelocationInfoCtorFn - Construction function for this target's

  /// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)

  MCRelocationInfoCtorTy MCRelocationInfoCtorFn = nullptr;

  /// MCSymbolizerCtorFn - Construction function for this target's

  /// MCSymbolizer, if registered (default = llvm::createMCSymbolizer)

  MCSymbolizerCtorTy MCSymbolizerCtorFn = nullptr;

  /// CustomBehaviourCtorFn - Construction function for this target's

  /// CustomBehaviour, if registered (default = nullptr).

  CustomBehaviourCtorTy CustomBehaviourCtorFn = nullptr;

  /// InstrPostProcessCtorFn - Construction function for this target's

  /// InstrPostProcess, if registered (default = nullptr).

  InstrPostProcessCtorTy InstrPostProcessCtorFn = nullptr;

  /// InstrumentManagerCtorFn - Construction function for this target's

  /// InstrumentManager, if registered (default = nullptr).

  InstrumentManagerCtorTy InstrumentManagerCtorFn = nullptr;

public:

  Target() = default;

  /// @name Target Information

  /// @{

  // getNext - Return the next registered target.

  const Target *getNext() const { return Next; }

  /// getName - Get the target name.

  const char *getName() const { return Name; }

  /// getShortDescription - Get a short description of the target.

  const char *getShortDescription() const { return ShortDesc; }

  /// getBackendName - Get the backend name.

  const char *getBackendName() const { return BackendName; }

  /// @}

  /// @name Feature Predicates

  /// @{

  /// hasJIT - Check if this targets supports the just-in-time compilation.

  bool hasJIT() const { return HasJIT; }

  /// hasTargetMachine - Check if this target supports code generation.

  bool hasTargetMachine() const { return TargetMachineCtorFn != nullptr; }

  /// hasMCAsmBackend - Check if this target supports .o generation.

  bool hasMCAsmBackend() const { return MCAsmBackendCtorFn != nullptr; }

  /// hasMCAsmParser - Check if this target supports assembly parsing.

  bool hasMCAsmParser() const { return MCAsmParserCtorFn != nullptr; }

  /// @}

  /// @name Feature Constructors

  /// @{

  /// createMCAsmInfo - Create a MCAsmInfo implementation for the specified

  /// target triple.

  ///

  /// \param TheTriple This argument is used to determine the target machine

  /// feature set; it should always be provided. Generally this should be

  /// either the target triple from the module, or the target triple of the

  /// host if that does not exist.

  MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple,

                             const MCTargetOptions &Options) const {

    if (!MCAsmInfoCtorFn)

      return nullptr;

    return MCAsmInfoCtorFn(MRI, Triple(TheTriple), Options);

  }

  /// Create a MCObjectFileInfo implementation for the specified target

  /// triple.

  ///

  MCObjectFileInfo *createMCObjectFileInfo(MCContext &Ctx, bool PIC,

                                           bool LargeCodeModel = false) const {

    if (!MCObjectFileInfoCtorFn) {

      MCObjectFileInfo *MOFI = new MCObjectFileInfo();

      MOFI->initMCObjectFileInfo(Ctx, PIC, LargeCodeModel);

      return MOFI;

    }

    return MCObjectFileInfoCtorFn(Ctx, PIC, LargeCodeModel);

  }

  /// createMCInstrInfo - Create a MCInstrInfo implementation.

  ///

  MCInstrInfo *createMCInstrInfo() const {

    if (!MCInstrInfoCtorFn)

      return nullptr;

    return MCInstrInfoCtorFn();

  }

  /// createMCInstrAnalysis - Create a MCInstrAnalysis implementation.

  ///

  MCInstrAnalysis *createMCInstrAnalysis(const MCInstrInfo *Info) const {

    if (!MCInstrAnalysisCtorFn)

      return nullptr;

    return MCInstrAnalysisCtorFn(Info);

  }

  /// createMCRegInfo - Create a MCRegisterInfo implementation.

  ///

  MCRegisterInfo *createMCRegInfo(StringRef TT) const {

    if (!MCRegInfoCtorFn)

      return nullptr;

    return MCRegInfoCtorFn(Triple(TT));

  }

  /// createMCSubtargetInfo - Create a MCSubtargetInfo implementation.

  ///

  /// \param TheTriple This argument is used to determine the target machine

  /// feature set; it should always be provided. Generally this should be

  /// either the target triple from the module, or the target triple of the

  /// host if that does not exist.

  /// \param CPU This specifies the name of the target CPU.

  /// \param Features This specifies the string representation of the

  /// additional target features.

  MCSubtargetInfo *createMCSubtargetInfo(StringRef TheTriple, StringRef CPU,

                                         StringRef Features) const {

    if (!MCSubtargetInfoCtorFn)

      return nullptr;

    return MCSubtargetInfoCtorFn(Triple(TheTriple), CPU, Features);

  }

  /// createTargetMachine - Create a target specific machine implementation

  /// for the specified \p Triple.

  ///

  /// \param TT This argument is used to determine the target machine

  /// feature set; it should always be provided. Generally this should be

  /// either the target triple from the module, or the target triple of the

  /// host if that does not exist.

  TargetMachine *createTargetMachine(

      StringRef TT, StringRef CPU, StringRef Features,

      const TargetOptions &Options, std::optional<Reloc::Model> RM,

      std::optional<CodeModel::Model> CM = std::nullopt,

      CodeGenOpt::Level OL = CodeGenOpt::Default, bool JIT = false) const {

    if (!TargetMachineCtorFn)

      return nullptr;

    return TargetMachineCtorFn(*this, Triple(TT), CPU, Features, Options, RM,

                               CM, OL, JIT);

  }

  /// createMCAsmBackend - Create a target specific assembly parser.

  MCAsmBackend *createMCAsmBackend(const MCSubtargetInfo &STI,

                                   const MCRegisterInfo &MRI,

                                   const MCTargetOptions &Options) const {

    if (!MCAsmBackendCtorFn)

      return nullptr;

    return MCAsmBackendCtorFn(*this, STI, MRI, Options);

  }

  /// createMCAsmParser - Create a target specific assembly parser.

  ///

  /// \param Parser The target independent parser implementation to use for

  /// parsing and lexing.

  MCTargetAsmParser *createMCAsmParser(const MCSubtargetInfo &STI,

                                       MCAsmParser &Parser,

                                       const MCInstrInfo &MII,

                                       const MCTargetOptions &Options) const {

    if (!MCAsmParserCtorFn)

      return nullptr;

    return MCAsmParserCtorFn(STI, Parser, MII, Options);

  }

  /// createAsmPrinter - Create a target specific assembly printer pass.  This

  /// takes ownership of the MCStreamer object.

  AsmPrinter *createAsmPrinter(TargetMachine &TM,

                               std::unique_ptr<MCStreamer> &&Streamer) const {

    if (!AsmPrinterCtorFn)

      return nullptr;

    return AsmPrinterCtorFn(TM, std::move(Streamer));

  }

  MCDisassembler *createMCDisassembler(const MCSubtargetInfo &STI,

                                       MCContext &Ctx) const {

    if (!MCDisassemblerCtorFn)

      return nullptr;

    return MCDisassemblerCtorFn(*this, STI, Ctx);

  }

  MCInstPrinter *createMCInstPrinter(const Triple &T, unsigned SyntaxVariant,

                                     const MCAsmInfo &MAI,

                                     const MCInstrInfo &MII,

                                     const MCRegisterInfo &MRI) const {

    if (!MCInstPrinterCtorFn)

      return nullptr;

    return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);

  }

  /// createMCCodeEmitter - Create a target specific code emitter.

  MCCodeEmitter *createMCCodeEmitter(const MCInstrInfo &II,

                                     MCContext &Ctx) const {

    if (!MCCodeEmitterCtorFn)

      return nullptr;

    return MCCodeEmitterCtorFn(II, Ctx);

  }

  /// Create a target specific MCStreamer.

  ///

  /// \param T The target triple.

  /// \param Ctx The target context.

  /// \param TAB The target assembler backend object. Takes ownership.

  /// \param OW The stream object.

  /// \param Emitter The target independent assembler object.Takes ownership.

  /// \param RelaxAll Relax all fixups?

  MCStreamer *createMCObjectStreamer(const Triple &T, MCContext &Ctx,

                                     std::unique_ptr<MCAsmBackend> &&TAB,

                                     std::unique_ptr<MCObjectWriter> &&OW,

                                     std::unique_ptr<MCCodeEmitter> &&Emitter,

                                     const MCSubtargetInfo &STI, bool RelaxAll,

                                     bool IncrementalLinkerCompatible,

                                     bool DWARFMustBeAtTheEnd) const {

    MCStreamer *S = nullptr;

    switch (T.getObjectFormat()) {

    case Triple::UnknownObjectFormat:

      llvm_unreachable("Unknown object format");

    case Triple::COFF:

      assert(T.isOSWindows() && "only Windows COFF is supported");

      S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),

                             std::move(Emitter), RelaxAll,

                             IncrementalLinkerCompatible);

      break;

    case Triple::MachO:

      if (MachOStreamerCtorFn)

        S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),

                                std::move(Emitter), RelaxAll,

                                DWARFMustBeAtTheEnd);

      else

        S = createMachOStreamer(Ctx, std::move(TAB), std::move(OW),

                                std::move(Emitter), RelaxAll,

                                DWARFMustBeAtTheEnd);

      break;

    case Triple::ELF:

      if (ELFStreamerCtorFn)

        S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),

                              std::move(Emitter), RelaxAll);

      else

        S = createELFStreamer(Ctx, std::move(TAB), std::move(OW),

                              std::move(Emitter), RelaxAll);

      break;

    case Triple::Wasm:

      if (WasmStreamerCtorFn)

        S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),

                               std::move(Emitter), RelaxAll);

      else

        S = createWasmStreamer(Ctx, std::move(TAB), std::move(OW),

                               std::move(Emitter), RelaxAll);

      break;

    case Triple::GOFF:

      report_fatal_error("GOFF MCObjectStreamer not implemented yet");

    case Triple::XCOFF:

      if (XCOFFStreamerCtorFn)

        S = XCOFFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),

                                std::move(Emitter), RelaxAll);

      else

        S = createXCOFFStreamer(Ctx, std::move(TAB), std::move(OW),

                                std::move(Emitter), RelaxAll);

      break;

    case Triple::SPIRV:

      if (SPIRVStreamerCtorFn)

        S = SPIRVStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),

                                std::move(Emitter), RelaxAll);

      else

        S = createSPIRVStreamer(Ctx, std::move(TAB), std::move(OW),

                                std::move(Emitter), RelaxAll);

      break;

    case Triple::DXContainer:

      if (DXContainerStreamerCtorFn)

        S = DXContainerStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),

                              std::move(Emitter), RelaxAll);

      else

        S = createDXContainerStreamer(Ctx, std::move(TAB), std::move(OW),

                                      std::move(Emitter), RelaxAll);

      break;

    }

    if (ObjectTargetStreamerCtorFn)

      ObjectTargetStreamerCtorFn(*S, STI);

    return S;

  }

  MCStreamer *createAsmStreamer(MCContext &Ctx,

                                std::unique_ptr<formatted_raw_ostream> OS,

                                bool IsVerboseAsm, bool UseDwarfDirectory,

                                MCInstPrinter *InstPrint,

                                std::unique_ptr<MCCodeEmitter> &&CE,

                                std::unique_ptr<MCAsmBackend> &&TAB,

                                bool ShowInst) const {

    formatted_raw_ostream &OSRef = *OS;

    MCStreamer *S = llvm::createAsmStreamer(

        Ctx, std::move(OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,

        std::move(CE), std::move(TAB), ShowInst);

    createAsmTargetStreamer(*S, OSRef, InstPrint, IsVerboseAsm);

    return S;

  }

  MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,

                                            formatted_raw_ostream &OS,

                                            MCInstPrinter *InstPrint,

                                            bool IsVerboseAsm) const {

    if (AsmTargetStreamerCtorFn)

      return AsmTargetStreamerCtorFn(S, OS, InstPrint, IsVerboseAsm);

    return nullptr;

  }

  MCStreamer *createNullStreamer(MCContext &Ctx) const {

    MCStreamer *S = llvm::createNullStreamer(Ctx);

    createNullTargetStreamer(*S);

    return S;

  }

  MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) const {

    if (NullTargetStreamerCtorFn)

      return NullTargetStreamerCtorFn(S);

    return nullptr;

  }

  /// createMCRelocationInfo - Create a target specific MCRelocationInfo.

  ///

  /// \param TT The target triple.

  /// \param Ctx The target context.

  MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) const {

    MCRelocationInfoCtorTy Fn = MCRelocationInfoCtorFn

                                    ? MCRelocationInfoCtorFn

                                    : llvm::createMCRelocationInfo;

    return Fn(Triple(TT), Ctx);

  }

  /// createMCSymbolizer - Create a target specific MCSymbolizer.

  ///

  /// \param TT The target triple.

  /// \param GetOpInfo The function to get the symbolic information for

  /// operands.

  /// \param SymbolLookUp The function to lookup a symbol name.

  /// \param DisInfo The pointer to the block of symbolic information for above

  /// call

  /// back.

  /// \param Ctx The target context.

  /// \param RelInfo The relocation information for this target. Takes

  /// ownership.

  MCSymbolizer *

  createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,

                     LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo,

                     MCContext *Ctx,

                     std::unique_ptr<MCRelocationInfo> &&RelInfo) const {

    MCSymbolizerCtorTy Fn =

        MCSymbolizerCtorFn ? MCSymbolizerCtorFn : llvm::createMCSymbolizer;

    return Fn(Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,

              std::move(RelInfo));

  }

  /// createCustomBehaviour - Create a target specific CustomBehaviour.

  /// This class is used by llvm-mca and requires backend functionality.

  mca::CustomBehaviour *createCustomBehaviour(const MCSubtargetInfo &STI,

                                              const mca::SourceMgr &SrcMgr,

                                              const MCInstrInfo &MCII) const {

    if (CustomBehaviourCtorFn)

      return CustomBehaviourCtorFn(STI, SrcMgr, MCII);

    return nullptr;

  }

  /// createInstrPostProcess - Create a target specific InstrPostProcess.

  /// This class is used by llvm-mca and requires backend functionality.

  mca::InstrPostProcess *createInstrPostProcess(const MCSubtargetInfo &STI,

                                                const MCInstrInfo &MCII) const {

    if (InstrPostProcessCtorFn)

      return InstrPostProcessCtorFn(STI, MCII);

    return nullptr;

  }

  /// createInstrumentManager - Create a target specific

  /// InstrumentManager. This class is used by llvm-mca and requires

  /// backend functionality.

  mca::InstrumentManager *

  createInstrumentManager(const MCSubtargetInfo &STI,

                          const MCInstrInfo &MCII) const {

    if (InstrumentManagerCtorFn)

      return InstrumentManagerCtorFn(STI, MCII);

    return nullptr;

  }

  /// @}

};

/// TargetRegistry - Generic interface to target specific features.

struct TargetRegistry {

  // FIXME: Make this a namespace, probably just move all the Register*

  // functions into Target (currently they all just set members on the Target

  // anyway, and Target friends this class so those functions can...

  // function).

  TargetRegistry() = delete;

  class iterator {

    friend struct TargetRegistry;

    const Target *Current = nullptr;

    explicit iterator(Target *T) : Current(T) {}

  public:

    using iterator_category = std::forward_iterator_tag;

    using value_type = Target;

    using difference_type = std::ptrdiff_t;

    using pointer = value_type *;

    using reference = value_type &;

    iterator() = default;

    bool operator==(const iterator &x) const { return Current == x.Current; }

    bool operator!=(const iterator &x) const { return !operator==(x); }

    // Iterator traversal: forward iteration only

    iterator &operator++() { // Preincrement

      assert(Current && "Cannot increment end iterator!");

      Current = Current->getNext();

      return *this;

    }

    iterator operator++(int) { // Postincrement

      iterator tmp = *this;

      ++*this;

      return tmp;

    }

    const Target &operator*() const {

      assert(Current && "Cannot dereference end iterator!");

      return *Current;

    }

    const Target *operator->() const { return &operator*(); }

  };

  /// printRegisteredTargetsForVersion - Print the registered targets

  /// appropriately for inclusion in a tool's version output.

  static void printRegisteredTargetsForVersion(raw_ostream &OS);

  /// @name Registry Access

  /// @{

  static iterator_range<iterator> targets();

  /// lookupTarget - Lookup a target based on a target triple.

  ///

  /// \param Triple - The triple to use for finding a target.

  /// \param Error - On failure, an error string describing why no target was

  /// found.

  static const Target *lookupTarget(const std::string &Triple,

                                    std::string &Error);

  /// lookupTarget - Lookup a target based on an architecture name

  /// and a target triple.  If the architecture name is non-empty,

  /// then the lookup is done by architecture.  Otherwise, the target

  /// triple is used.

  ///

  /// \param ArchName - The architecture to use for finding a target.

  /// \param TheTriple - The triple to use for finding a target.  The

  /// triple is updated with canonical architecture name if a lookup

  /// by architecture is done.

  /// \param Error - On failure, an error string describing why no target was

  /// found.