TargetRegistry.h

Go to the documentation of this file.

//===- 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/iterator_range.h"
#include "llvm/MC/MCObjectFileInfo.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/TargetParser/Triple.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,
MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,
 std::unique_ptr<MCAsmBackend> &&TAB);

MCStreamer *createELFStreamer(MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&CE);
MCStreamer *createGOFFStreamer(MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&CE);
MCStreamer *createMachOStreamer(MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&CE,
bool DWARFMustBeAtTheEnd,
bool LabelSections = false);
MCStreamer *createWasmStreamer(MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&CE);
MCStreamer *createSPIRVStreamer(MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&CE);
MCStreamer *createDXContainerStreamer(MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&CE);

MCRelocationInfo *createMCRelocationInfo(constTriple &TT, MCContext &Ctx);

MCSymbolizer *createMCSymbolizer(constTriple &TT, LLVMOpInfoCallback GetOpInfo,
LLVMSymbolLookupCallback SymbolLookUp,
void *DisInfo, MCContext *Ctx,
 std::unique_ptr<MCRelocationInfo> &&RelInfo);

mca::CustomBehaviour *createCustomBehaviour(constMCSubtargetInfo &STI,
constmca::SourceMgr &SrcMgr,
constMCInstrInfo &MCII);

mca::InstrPostProcess *createInstrPostProcess(constMCSubtargetInfo &STI,
constMCInstrInfo &MCII);

mca::InstrumentManager *createInstrumentManager(constMCSubtargetInfo &STI,
constMCInstrInfo &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:
friendstruct TargetRegistry;

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

using MCAsmInfoCtorFnTy = MCAsmInfo *(*)(constMCRegisterInfo &MRI,
constTriple &TT,
constMCTargetOptions &Options);
using MCObjectFileInfoCtorFnTy = MCObjectFileInfo *(*)(MCContext &Ctx,
boolPIC,
bool LargeCodeModel);
using MCInstrInfoCtorFnTy = MCInstrInfo *(*)();
using MCInstrAnalysisCtorFnTy = MCInstrAnalysis *(*)(constMCInstrInfo *Info);
using MCRegInfoCtorFnTy = MCRegisterInfo *(*)(constTriple &TT);
using MCSubtargetInfoCtorFnTy = MCSubtargetInfo *(*)(constTriple &TT,
StringRef CPU,
StringRef Features);
using TargetMachineCtorTy = TargetMachine
 *(*)(constTarget &T, constTriple &TT, StringRef CPU, StringRef Features,
constTargetOptions &Options, std::optional<Reloc::Model> RM,
 std::optional<CodeModel::Model> CM, CodeGenOptLevel 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 *(*)(constTarget &T,
constMCSubtargetInfo &STI,
constMCRegisterInfo &MRI,
constMCTargetOptions &Options);
using MCAsmParserCtorTy = MCTargetAsmParser *(*)(
constMCSubtargetInfo &STI, MCAsmParser &P, constMCInstrInfo &MII,
constMCTargetOptions &Options);
using MCDisassemblerCtorTy = MCDisassembler *(*)(constTarget &T,
constMCSubtargetInfo &STI,
MCContext &Ctx);
using MCInstPrinterCtorTy = MCInstPrinter *(*)(constTriple &T,
unsigned SyntaxVariant,
constMCAsmInfo &MAI,
constMCInstrInfo &MII,
constMCRegisterInfo &MRI);
using MCCodeEmitterCtorTy = MCCodeEmitter *(*)(constMCInstrInfo &II,
MCContext &Ctx);
using ELFStreamerCtorTy =
MCStreamer *(*)(constTriple &T, MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&Emitter);
using MachOStreamerCtorTy =
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&Emitter);
using COFFStreamerCtorTy =
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&Emitter);
using XCOFFStreamerCtorTy =
MCStreamer *(*)(constTriple &T, MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> &&TAB,
 std::unique_ptr<MCObjectWriter> &&OW,
 std::unique_ptr<MCCodeEmitter> &&Emitter);

using NullTargetStreamerCtorTy = MCTargetStreamer *(*)(MCStreamer &S);
using AsmTargetStreamerCtorTy =
MCTargetStreamer *(*)(MCStreamer &S, formatted_raw_ostream &OS,
MCInstPrinter *InstPrint);
using ObjectTargetStreamerCtorTy = MCTargetStreamer *(*)(
MCStreamer &S, constMCSubtargetInfo &STI);
using MCRelocationInfoCtorTy = MCRelocationInfo *(*)(constTriple &TT,
MCContext &Ctx);
using MCSymbolizerCtorTy = MCSymbolizer *(*)(
constTriple &TT, LLVMOpInfoCallback GetOpInfo,
LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx,
 std::unique_ptr<MCRelocationInfo> &&RelInfo);

using CustomBehaviourCtorTy =
mca::CustomBehaviour *(*)(constMCSubtargetInfo &STI,
constmca::SourceMgr &SrcMgr,
constMCInstrInfo &MCII);

using InstrPostProcessCtorTy =
mca::InstrPostProcess *(*)(constMCSubtargetInfo &STI,
constMCInstrInfo &MCII);

using InstrumentManagerCtorTy =
mca::InstrumentManager *(*)(constMCSubtargetInfo &STI,
constMCInstrInfo &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.
constchar *Name;

 /// ShortDesc - A short description of the target.
constchar *ShortDesc;

 /// BackendName - The name of the backend implementation. This must match the
 /// name of the 'def X : Target ...' in TableGen.
constchar *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;
XCOFFStreamerCtorTy XCOFFStreamerCtorFn = 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.
constTarget *getNext() const { return Next; }

 /// getName - Get the target name.
constchar *getName() const { returnName; }

 /// getShortDescription - Get a short description of the target.
constchar *getShortDescription() const { return ShortDesc; }

 /// getBackendName - Get the backend name.
constchar *getBackendName() const { return BackendName; }

 /// @}
 /// @name Feature Predicates
 /// @{

 /// hasJIT - Check if this targets supports the just-in-time compilation.
boolhasJIT() const { return HasJIT; }

 /// hasTargetMachine - Check if this target supports code generation.
boolhasTargetMachine() const { return TargetMachineCtorFn != nullptr; }

 /// hasMCAsmBackend - Check if this target supports .o generation.
boolhasMCAsmBackend() const { return MCAsmBackendCtorFn != nullptr; }

 /// hasMCAsmParser - Check if this target supports assembly parsing.
boolhasMCAsmParser() 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(constMCRegisterInfo &MRI, StringRef TheTriple,
constMCTargetOptions &Options) const {
if (!MCAsmInfoCtorFn)
returnnullptr;
return MCAsmInfoCtorFn(MRI, Triple(TheTriple), Options);
 }

 /// Create a MCObjectFileInfo implementation for the specified target
 /// triple.
 ///
MCObjectFileInfo *createMCObjectFileInfo(MCContext &Ctx, boolPIC,
bool LargeCodeModel = false) const {
if (!MCObjectFileInfoCtorFn) {
MCObjectFileInfo *MOFI = newMCObjectFileInfo();
 MOFI->initMCObjectFileInfo(Ctx, PIC, LargeCodeModel);
return MOFI;
 }
return MCObjectFileInfoCtorFn(Ctx, PIC, LargeCodeModel);
 }

 /// createMCInstrInfo - Create a MCInstrInfo implementation.
 ///
MCInstrInfo *createMCInstrInfo() const {
if (!MCInstrInfoCtorFn)
returnnullptr;
return MCInstrInfoCtorFn();
 }

 /// createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
 ///
MCInstrAnalysis *createMCInstrAnalysis(constMCInstrInfo *Info) const {
if (!MCInstrAnalysisCtorFn)
returnnullptr;
return MCInstrAnalysisCtorFn(Info);
 }

 /// createMCRegInfo - Create a MCRegisterInfo implementation.
 ///
MCRegisterInfo *createMCRegInfo(StringRef TT) const {
if (!MCRegInfoCtorFn)
returnnullptr;
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)
returnnullptr;
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,
constTargetOptions &Options, std::optional<Reloc::Model> RM,
 std::optional<CodeModel::Model> CM = std::nullopt,
CodeGenOptLevel OL = CodeGenOptLevel::Default, bool JIT = false) const {
if (!TargetMachineCtorFn)
returnnullptr;
return TargetMachineCtorFn(*this, Triple(TT), CPU, Features, Options, RM,
 CM, OL, JIT);
 }

 /// createMCAsmBackend - Create a target specific assembly parser.
MCAsmBackend *createMCAsmBackend(constMCSubtargetInfo &STI,
constMCRegisterInfo &MRI,
constMCTargetOptions &Options) const {
if (!MCAsmBackendCtorFn)
returnnullptr;
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(constMCSubtargetInfo &STI,
MCAsmParser &Parser,
constMCInstrInfo &MII,
constMCTargetOptions &Options) const {
if (!MCAsmParserCtorFn)
returnnullptr;
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)
returnnullptr;
return AsmPrinterCtorFn(TM, std::move(Streamer));
 }

MCDisassembler *createMCDisassembler(constMCSubtargetInfo &STI,
MCContext &Ctx) const {
if (!MCDisassemblerCtorFn)
returnnullptr;
return MCDisassemblerCtorFn(*this, STI, Ctx);
 }

MCInstPrinter *createMCInstPrinter(constTriple &T, unsigned SyntaxVariant,
constMCAsmInfo &MAI,
constMCInstrInfo &MII,
constMCRegisterInfo &MRI) const {
if (!MCInstPrinterCtorFn)
returnnullptr;
return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);
 }

 /// createMCCodeEmitter - Create a target specific code emitter.
MCCodeEmitter *createMCCodeEmitter(constMCInstrInfo &II,
MCContext &Ctx) const {
if (!MCCodeEmitterCtorFn)
returnnullptr;
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.
MCStreamer *createMCObjectStreamer(constTriple &T, MCContext &Ctx,
 std::unique_ptr<MCAsmBackend> TAB,
 std::unique_ptr<MCObjectWriter> OW,
 std::unique_ptr<MCCodeEmitter> Emitter,
constMCSubtargetInfo &STI) const;
LLVM_DEPRECATED("Use the overload without the 3 trailing bool", "")
MCStreamer *createMCObjectStreamer(constTriple &T, MCContext &Ctx,
std::unique_ptr<MCAsmBackend> &&TAB,
std::unique_ptr<MCObjectWriter> &&OW,
std::unique_ptr<MCCodeEmitter> &&Emitter,
constMCSubtargetInfo &STI, bool, bool,
bool) const;

MCStreamer *createAsmStreamer(MCContext &Ctx,
std::unique_ptr<formatted_raw_ostream> OS,
MCInstPrinter *IP,
std::unique_ptr<MCCodeEmitter> CE,
std::unique_ptr<MCAsmBackend> TAB) const;
LLVM_DEPRECATED("Use the overload without the 3 unused bool", "")
MCStreamer *
createAsmStreamer(MCContext &Ctx, std::unique_ptr<formatted_raw_ostream> OS,
bool IsVerboseAsm, bool UseDwarfDirectory,
MCInstPrinter *IP, std::unique_ptr<MCCodeEmitter> &&CE,
std::unique_ptr<MCAsmBackend> &&TAB, bool ShowInst) const;

MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
formatted_raw_ostream &OS,
MCInstPrinter *InstPrint) const {
if (AsmTargetStreamerCtorFn)
return AsmTargetStreamerCtorFn(S, OS, InstPrint);
returnnullptr;
 }

MCStreamer *createNullStreamer(MCContext &Ctx) const {
MCStreamer *S = llvm::createNullStreamer(Ctx);
createNullTargetStreamer(*S);
return S;
 }

MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) const {
if (NullTargetStreamerCtorFn)
return NullTargetStreamerCtorFn(S);
returnnullptr;
 }

 /// 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(constMCSubtargetInfo &STI,
constmca::SourceMgr &SrcMgr,
constMCInstrInfo &MCII) const {
if (CustomBehaviourCtorFn)
return CustomBehaviourCtorFn(STI, SrcMgr, MCII);
returnnullptr;
 }

 /// createInstrPostProcess - Create a target specific InstrPostProcess.
 /// This class is used by llvm-mca and requires backend functionality.
mca::InstrPostProcess *createInstrPostProcess(constMCSubtargetInfo &STI,
constMCInstrInfo &MCII) const {
if (InstrPostProcessCtorFn)
return InstrPostProcessCtorFn(STI, MCII);
returnnullptr;
 }

 /// createInstrumentManager - Create a target specific
 /// InstrumentManager. This class is used by llvm-mca and requires
 /// backend functionality.
mca::InstrumentManager *
createInstrumentManager(constMCSubtargetInfo &STI,
constMCInstrInfo &MCII) const {
if (InstrumentManagerCtorFn)
return InstrumentManagerCtorFn(STI, MCII);
returnnullptr;
 }

 /// @}
};

/// 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 {
friendstruct TargetRegistry;

constTarget *Current = nullptr;

explicititerator(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;

booloperator==(constiterator &x) const { return Current == x.Current; }
booloperator!=(constiterator &x) const { return !operator==(x); }

// Iterator traversal: forward iteration only
iterator &operator++() { // Preincrement
assert(Current && "Cannot increment end iterator!");
 Current = Current->getNext();
return *this;
 }
iteratoroperator++(int) { // Postincrement
iterator tmp = *this;
 ++*this;
return tmp;
 }

constTarget &operator*() const {
assert(Current && "Cannot dereference end iterator!");
return *Current;
 }

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

 /// printRegisteredTargetsForVersion - Print the registered targets
 /// appropriately for inclusion in a tool's version output.
staticvoidprintRegisteredTargetsForVersion(raw_ostream &OS);

 /// @name Registry Access
 /// @{

staticiterator_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.
staticconstTarget *lookupTarget(StringRefTriple, 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.
staticconstTarget *lookupTarget(StringRef ArchName, Triple &TheTriple,
 std::string &Error);

 /// @}
 /// @name Target Registration
 /// @{

 /// RegisterTarget - Register the given target. Attempts to register a
 /// target which has already been registered will be ignored.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Name - The target name. This should be a static string.
 /// @param ShortDesc - A short target description. This should be a static
 /// string.
 /// @param BackendName - The name of the backend. This should be a static
 /// string that is the same for all targets that share a backend
 /// implementation and must match the name used in the 'def X : Target ...' in
 /// TableGen.
 /// @param ArchMatchFn - The arch match checking function for this target.
 /// @param HasJIT - Whether the target supports JIT code
 /// generation.
staticvoidRegisterTarget(Target &T, constchar *Name, constchar *ShortDesc,
constchar *BackendName,
Target::ArchMatchFnTy ArchMatchFn,
bool HasJIT = false);

 /// RegisterMCAsmInfo - Register a MCAsmInfo implementation for the
 /// given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct a MCAsmInfo for the target.
staticvoidRegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn) {
T.MCAsmInfoCtorFn = Fn;
 }

 /// Register a MCObjectFileInfo implementation for the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct a MCObjectFileInfo for the target.
staticvoidRegisterMCObjectFileInfo(Target &T,
Target::MCObjectFileInfoCtorFnTy Fn) {
T.MCObjectFileInfoCtorFn = Fn;
 }

 /// RegisterMCInstrInfo - Register a MCInstrInfo implementation for the
 /// given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct a MCInstrInfo for the target.
staticvoidRegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn) {
T.MCInstrInfoCtorFn = Fn;
 }

 /// RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for
 /// the given target.
staticvoidRegisterMCInstrAnalysis(Target &T,
Target::MCInstrAnalysisCtorFnTy Fn) {
T.MCInstrAnalysisCtorFn = Fn;
 }

 /// RegisterMCRegInfo - Register a MCRegisterInfo implementation for the
 /// given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct a MCRegisterInfo for the target.
staticvoidRegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn) {
T.MCRegInfoCtorFn = Fn;
 }

 /// RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for
 /// the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct a MCSubtargetInfo for the target.
staticvoidRegisterMCSubtargetInfo(Target &T,
Target::MCSubtargetInfoCtorFnTy Fn) {
T.MCSubtargetInfoCtorFn = Fn;
 }

 /// RegisterTargetMachine - Register a TargetMachine implementation for the
 /// given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct a TargetMachine for the target.
staticvoidRegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn) {
T.TargetMachineCtorFn = Fn;
 }

 /// RegisterMCAsmBackend - Register a MCAsmBackend implementation for the
 /// given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an AsmBackend for the target.
staticvoidRegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn) {
T.MCAsmBackendCtorFn = Fn;
 }

 /// RegisterMCAsmParser - Register a MCTargetAsmParser implementation for
 /// the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an MCTargetAsmParser for the target.
staticvoidRegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn) {
T.MCAsmParserCtorFn = Fn;
 }

 /// RegisterAsmPrinter - Register an AsmPrinter implementation for the given
 /// target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an AsmPrinter for the target.
staticvoidRegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn) {
T.AsmPrinterCtorFn = Fn;
 }

 /// RegisterMCDisassembler - Register a MCDisassembler implementation for
 /// the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an MCDisassembler for the target.
staticvoidRegisterMCDisassembler(Target &T,
Target::MCDisassemblerCtorTy Fn) {
T.MCDisassemblerCtorFn = Fn;
 }

 /// RegisterMCInstPrinter - Register a MCInstPrinter implementation for the
 /// given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an MCInstPrinter for the target.
staticvoidRegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn) {
T.MCInstPrinterCtorFn = Fn;
 }

 /// RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the
 /// given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an MCCodeEmitter for the target.
staticvoidRegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn) {
T.MCCodeEmitterCtorFn = Fn;
 }

staticvoidRegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn) {
T.COFFStreamerCtorFn = Fn;
 }

staticvoidRegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn) {
T.MachOStreamerCtorFn = Fn;
 }

staticvoidRegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn) {
T.ELFStreamerCtorFn = Fn;
 }

staticvoidRegisterXCOFFStreamer(Target &T, Target::XCOFFStreamerCtorTy Fn) {
T.XCOFFStreamerCtorFn = Fn;
 }

staticvoidRegisterNullTargetStreamer(Target &T,
Target::NullTargetStreamerCtorTy Fn) {
T.NullTargetStreamerCtorFn = Fn;
 }

staticvoidRegisterAsmTargetStreamer(Target &T,
Target::AsmTargetStreamerCtorTy Fn) {
T.AsmTargetStreamerCtorFn = Fn;
 }

staticvoid
RegisterObjectTargetStreamer(Target &T,
Target::ObjectTargetStreamerCtorTy Fn) {
T.ObjectTargetStreamerCtorFn = Fn;
 }

 /// RegisterMCRelocationInfo - Register an MCRelocationInfo
 /// implementation for the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an MCRelocationInfo for the target.
staticvoidRegisterMCRelocationInfo(Target &T,
Target::MCRelocationInfoCtorTy Fn) {
T.MCRelocationInfoCtorFn = Fn;
 }

 /// RegisterMCSymbolizer - Register an MCSymbolizer
 /// implementation for the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an MCSymbolizer for the target.
staticvoidRegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn) {
T.MCSymbolizerCtorFn = Fn;
 }

 /// RegisterCustomBehaviour - Register a CustomBehaviour
 /// implementation for the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct a CustomBehaviour for the target.
staticvoidRegisterCustomBehaviour(Target &T,
Target::CustomBehaviourCtorTy Fn) {
T.CustomBehaviourCtorFn = Fn;
 }

 /// RegisterInstrPostProcess - Register an InstrPostProcess
 /// implementation for the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an InstrPostProcess for the target.
staticvoidRegisterInstrPostProcess(Target &T,
Target::InstrPostProcessCtorTy Fn) {
T.InstrPostProcessCtorFn = Fn;
 }

 /// RegisterInstrumentManager - Register an InstrumentManager
 /// implementation for the given target.
 ///
 /// Clients are responsible for ensuring that registration doesn't occur
 /// while another thread is attempting to access the registry. Typically
 /// this is done by initializing all targets at program startup.
 ///
 /// @param T - The target being registered.
 /// @param Fn - A function to construct an InstrumentManager for the
 /// target.
staticvoidRegisterInstrumentManager(Target &T,
Target::InstrumentManagerCtorTy Fn) {
T.InstrumentManagerCtorFn = Fn;
 }

 /// @}
};

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

/// RegisterTarget - Helper template for registering a target, for use in the
/// target's initialization function. Usage:
///
///
/// Target &getTheFooTarget() { // The global target instance.
/// static Target TheFooTarget;
/// return TheFooTarget;
/// }
/// extern "C" void LLVMInitializeFooTargetInfo() {
/// RegisterTarget<Triple::foo> X(getTheFooTarget(), "foo", "Foo
/// description", "Foo" /* Backend Name */);
/// }
template <Triple::ArchType TargetArchType = Triple::UnknownArch,
bool HasJIT = false>
struct RegisterTarget {
RegisterTarget(Target &T, constchar *Name, constchar *Desc,
constchar *BackendName) {
TargetRegistry::RegisterTarget(T, Name, Desc, BackendName, &getArchMatch,
 HasJIT);
 }

staticboolgetArchMatch(Triple::ArchType Arch) {
return Arch == TargetArchType;
 }
};

/// RegisterMCAsmInfo - Helper template for registering a target assembly info
/// implementation. This invokes the static "Create" method on the class to
/// actually do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCAsmInfo<FooMCAsmInfo> X(TheFooTarget);
/// }
template <class MCAsmInfoImpl> struct RegisterMCAsmInfo {
RegisterMCAsmInfo(Target &T) {
TargetRegistry::RegisterMCAsmInfo(T, &Allocator);
 }

private:
staticMCAsmInfo *Allocator(constMCRegisterInfo & /*MRI*/, constTriple &TT,
constMCTargetOptions &Options) {
returnnew MCAsmInfoImpl(TT, Options);
 }
};

/// RegisterMCAsmInfoFn - Helper template for registering a target assembly info
/// implementation. This invokes the specified function to do the
/// construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCAsmInfoFn X(TheFooTarget, TheFunction);
/// }
struct RegisterMCAsmInfoFn {
RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn) {
TargetRegistry::RegisterMCAsmInfo(T, Fn);
 }
};

/// Helper template for registering a target object file info implementation.
/// This invokes the static "Create" method on the class to actually do the
/// construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCObjectFileInfo<FooMCObjectFileInfo> X(TheFooTarget);
/// }
template <class MCObjectFileInfoImpl> struct RegisterMCObjectFileInfo {
RegisterMCObjectFileInfo(Target &T) {
TargetRegistry::RegisterMCObjectFileInfo(T, &Allocator);
 }

private:
staticMCObjectFileInfo *Allocator(MCContext &Ctx, boolPIC,
bool LargeCodeModel = false) {
returnnew MCObjectFileInfoImpl(Ctx, PIC, LargeCodeModel);
 }
};

/// Helper template for registering a target object file info implementation.
/// This invokes the specified function to do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCObjectFileInfoFn X(TheFooTarget, TheFunction);
/// }
struct RegisterMCObjectFileInfoFn {
RegisterMCObjectFileInfoFn(Target &T, Target::MCObjectFileInfoCtorFnTy Fn) {
TargetRegistry::RegisterMCObjectFileInfo(T, Fn);
 }
};

/// RegisterMCInstrInfo - Helper template for registering a target instruction
/// info implementation. This invokes the static "Create" method on the class
/// to actually do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCInstrInfo<FooMCInstrInfo> X(TheFooTarget);
/// }
template <class MCInstrInfoImpl> struct RegisterMCInstrInfo {
RegisterMCInstrInfo(Target &T) {
TargetRegistry::RegisterMCInstrInfo(T, &Allocator);
 }

private:
staticMCInstrInfo *Allocator() { returnnew MCInstrInfoImpl(); }
};

/// RegisterMCInstrInfoFn - Helper template for registering a target
/// instruction info implementation. This invokes the specified function to
/// do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCInstrInfoFn X(TheFooTarget, TheFunction);
/// }
struct RegisterMCInstrInfoFn {
RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn) {
TargetRegistry::RegisterMCInstrInfo(T, Fn);
 }
};

/// RegisterMCInstrAnalysis - Helper template for registering a target
/// instruction analyzer implementation. This invokes the static "Create"
/// method on the class to actually do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCInstrAnalysis<FooMCInstrAnalysis> X(TheFooTarget);
/// }
template <class MCInstrAnalysisImpl> struct RegisterMCInstrAnalysis {
RegisterMCInstrAnalysis(Target &T) {
TargetRegistry::RegisterMCInstrAnalysis(T, &Allocator);
 }

private:
staticMCInstrAnalysis *Allocator(constMCInstrInfo *Info) {
returnnew MCInstrAnalysisImpl(Info);
 }
};

/// RegisterMCInstrAnalysisFn - Helper template for registering a target
/// instruction analyzer implementation. This invokes the specified function
/// to do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCInstrAnalysisFn X(TheFooTarget, TheFunction);
/// }
struct RegisterMCInstrAnalysisFn {
RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn) {
TargetRegistry::RegisterMCInstrAnalysis(T, Fn);
 }
};

/// RegisterMCRegInfo - Helper template for registering a target register info
/// implementation. This invokes the static "Create" method on the class to
/// actually do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCRegInfo<FooMCRegInfo> X(TheFooTarget);
/// }
template <class MCRegisterInfoImpl> struct RegisterMCRegInfo {
RegisterMCRegInfo(Target &T) {
TargetRegistry::RegisterMCRegInfo(T, &Allocator);
 }

private:
staticMCRegisterInfo *Allocator(constTriple & /*TT*/) {
returnnew MCRegisterInfoImpl();
 }
};

/// RegisterMCRegInfoFn - Helper template for registering a target register
/// info implementation. This invokes the specified function to do the
/// construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCRegInfoFn X(TheFooTarget, TheFunction);
/// }
struct RegisterMCRegInfoFn {
RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn) {
TargetRegistry::RegisterMCRegInfo(T, Fn);
 }
};

/// RegisterMCSubtargetInfo - Helper template for registering a target
/// subtarget info implementation. This invokes the static "Create" method
/// on the class to actually do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCSubtargetInfo<FooMCSubtargetInfo> X(TheFooTarget);
/// }
template <class MCSubtargetInfoImpl> struct RegisterMCSubtargetInfo {
RegisterMCSubtargetInfo(Target &T) {
TargetRegistry::RegisterMCSubtargetInfo(T, &Allocator);
 }

private:
staticMCSubtargetInfo *Allocator(constTriple & /*TT*/, StringRef/*CPU*/,
StringRef/*FS*/) {
returnnew MCSubtargetInfoImpl();
 }
};

/// RegisterMCSubtargetInfoFn - Helper template for registering a target
/// subtarget info implementation. This invokes the specified function to
/// do the construction. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterMCSubtargetInfoFn X(TheFooTarget, TheFunction);
/// }
struct RegisterMCSubtargetInfoFn {
RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn) {
TargetRegistry::RegisterMCSubtargetInfo(T, Fn);
 }
};

/// RegisterTargetMachine - Helper template for registering a target machine
/// implementation, for use in the target machine initialization
/// function. Usage:
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
/// RegisterTargetMachine<FooTargetMachine> X(TheFooTarget);
/// }
template <class TargetMachineImpl> struct RegisterTargetMachine {
RegisterTargetMachine(Target &T) {
TargetRegistry::RegisterTargetMachine(T, &Allocator);
 }

private:
staticTargetMachine *
Allocator(constTarget &T, constTriple &TT, StringRef CPU, StringRef FS,
constTargetOptions &Options, std::optional<Reloc::Model> RM,
 std::optional<CodeModel::Model> CM, CodeGenOptLevel OL, bool JIT) {
returnnew TargetMachineImpl(T, TT, CPU, FS, Options, RM, CM, OL, JIT);
 }
};

/// RegisterMCAsmBackend - Helper template for registering a target specific
/// assembler backend. Usage:
///
/// extern "C" void LLVMInitializeFooMCAsmBackend() {
/// extern Target TheFooTarget;
/// RegisterMCAsmBackend<FooAsmLexer> X(TheFooTarget);
/// }
template <class MCAsmBackendImpl> struct RegisterMCAsmBackend {
RegisterMCAsmBackend(Target &T) {
TargetRegistry::RegisterMCAsmBackend(T, &Allocator);
 }

private:
staticMCAsmBackend *Allocator(constTarget &T, constMCSubtargetInfo &STI,
constMCRegisterInfo &MRI,
constMCTargetOptions &Options) {
returnnew MCAsmBackendImpl(T, STI, MRI);
 }
};

/// RegisterMCAsmParser - Helper template for registering a target specific
/// assembly parser, for use in the target machine initialization
/// function. Usage:
///
/// extern "C" void LLVMInitializeFooMCAsmParser() {
/// extern Target TheFooTarget;
/// RegisterMCAsmParser<FooAsmParser> X(TheFooTarget);
/// }
template <class MCAsmParserImpl> struct RegisterMCAsmParser {
RegisterMCAsmParser(Target &T) {
TargetRegistry::RegisterMCAsmParser(T, &Allocator);
 }

private:
staticMCTargetAsmParser *Allocator(constMCSubtargetInfo &STI,
MCAsmParser &P, constMCInstrInfo &MII,
constMCTargetOptions &Options) {
returnnew MCAsmParserImpl(STI, P, MII, Options);
 }
};

/// RegisterAsmPrinter - Helper template for registering a target specific
/// assembly printer, for use in the target machine initialization
/// function. Usage:
///
/// extern "C" void LLVMInitializeFooAsmPrinter() {
/// extern Target TheFooTarget;
/// RegisterAsmPrinter<FooAsmPrinter> X(TheFooTarget);
/// }
template <class AsmPrinterImpl> struct RegisterAsmPrinter {
RegisterAsmPrinter(Target &T) {
TargetRegistry::RegisterAsmPrinter(T, &Allocator);
 }

private:
staticAsmPrinter *Allocator(TargetMachine &TM,
 std::unique_ptr<MCStreamer> &&Streamer) {
returnnew AsmPrinterImpl(TM, std::move(Streamer));
 }
};

/// RegisterMCCodeEmitter - Helper template for registering a target specific
/// machine code emitter, for use in the target initialization
/// function. Usage:
///
/// extern "C" void LLVMInitializeFooMCCodeEmitter() {
/// extern Target TheFooTarget;
/// RegisterMCCodeEmitter<FooCodeEmitter> X(TheFooTarget);
/// }
template <class MCCodeEmitterImpl> struct RegisterMCCodeEmitter {
RegisterMCCodeEmitter(Target &T) {
TargetRegistry::RegisterMCCodeEmitter(T, &Allocator);
 }

private:
staticMCCodeEmitter *Allocator(constMCInstrInfo & /*II*/,
MCContext & /*Ctx*/) {
returnnew MCCodeEmitterImpl();
 }
};

} // end namespace llvm

#endif // LLVM_MC_TARGETREGISTRY_H