18 #ifndef LLVM_SUPPORT_TARGETREGISTRY_H 19 #define LLVM_SUPPORT_TARGETREGISTRY_H 46 class MCInstrAnalysis;
50 class MCRelocationInfo;
52 class MCSubtargetInfo;
54 class MCTargetAsmParser;
55 class MCTargetOptions;
56 class MCTargetStreamer;
58 class raw_pwrite_stream;
83 bool isVerboseAsm,
bool useDwarfDirectory,
84 MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,
85 std::unique_ptr<MCAsmBackend> &&TAB,
bool ShowInst);
88 std::unique_ptr<MCAsmBackend> &&TAB,
89 std::unique_ptr<MCObjectWriter> &&OW,
90 std::unique_ptr<MCCodeEmitter> &&CE,
93 std::unique_ptr<MCAsmBackend> &&TAB,
94 std::unique_ptr<MCObjectWriter> &&OW,
95 std::unique_ptr<MCCodeEmitter> &&CE,
96 bool RelaxAll,
bool DWARFMustBeAtTheEnd,
97 bool LabelSections =
false);
99 std::unique_ptr<MCAsmBackend> &&TAB,
100 std::unique_ptr<MCObjectWriter> &&OW,
101 std::unique_ptr<MCCodeEmitter> &&CE,
104 std::unique_ptr<MCAsmBackend> &&TAB,
105 std::unique_ptr<MCObjectWriter> &&OW,
106 std::unique_ptr<MCCodeEmitter> &&CE,
113 void *DisInfo, MCContext *Ctx,
114 std::unique_ptr<MCRelocationInfo> &&RelInfo);
158 unsigned SyntaxVariant,
167 std::unique_ptr<MCAsmBackend> &&TAB,
168 std::unique_ptr<MCObjectWriter> &&OW,
169 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
172 std::unique_ptr<MCObjectWriter> &&OW,
173 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll,
174 bool DWARFMustBeAtTheEnd);
177 std::unique_ptr<MCObjectWriter> &&OW,
178 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll,
179 bool IncrementalLinkerCompatible);
182 std::unique_ptr<MCAsmBackend> &&TAB,
183 std::unique_ptr<MCObjectWriter> &&OW,
184 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
196 std::unique_ptr<MCRelocationInfo> &&RelInfo);
210 const char *ShortDesc;
214 const char *BackendName;
237 MCSubtargetInfoCtorFnTy MCSubtargetInfoCtorFn;
241 TargetMachineCtorTy TargetMachineCtorFn;
245 MCAsmBackendCtorTy MCAsmBackendCtorFn;
249 MCAsmParserCtorTy MCAsmParserCtorFn;
253 AsmPrinterCtorTy AsmPrinterCtorFn;
257 MCDisassemblerCtorTy MCDisassemblerCtorFn;
261 MCInstPrinterCtorTy MCInstPrinterCtorFn;
265 MCCodeEmitterCtorTy MCCodeEmitterCtorFn;
268 COFFStreamerCtorTy COFFStreamerCtorFn =
nullptr;
269 MachOStreamerCtorTy MachOStreamerCtorFn =
nullptr;
270 ELFStreamerCtorTy ELFStreamerCtorFn =
nullptr;
271 WasmStreamerCtorTy WasmStreamerCtorFn =
nullptr;
279 AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn =
nullptr;
283 ObjectTargetStreamerCtorTy ObjectTargetStreamerCtorFn =
nullptr;
287 MCRelocationInfoCtorTy MCRelocationInfoCtorFn =
nullptr;
291 MCSymbolizerCtorTy MCSymbolizerCtorFn =
nullptr;
340 if (!MCAsmInfoCtorFn)
342 return MCAsmInfoCtorFn(MRI,
Triple(TheTriple));
348 if (!MCInstrInfoCtorFn)
350 return MCInstrInfoCtorFn();
356 if (!MCInstrAnalysisCtorFn)
358 return MCInstrAnalysisCtorFn(Info);
364 if (!MCRegInfoCtorFn)
366 return MCRegInfoCtorFn(
Triple(TT));
380 if (!MCSubtargetInfoCtorFn)
382 return MCSubtargetInfoCtorFn(
Triple(TheTriple), CPU, Features);
398 bool JIT =
false)
const {
399 if (!TargetMachineCtorFn)
401 return TargetMachineCtorFn(*
this,
Triple(TT), CPU, Features, Options, RM,
409 if (!MCAsmBackendCtorFn)
411 return MCAsmBackendCtorFn(*
this, STI, MRI, Options);
422 if (!MCAsmParserCtorFn)
424 return MCAsmParserCtorFn(STI, Parser, MII, Options);
430 std::unique_ptr<MCStreamer> &&Streamer)
const {
431 if (!AsmPrinterCtorFn)
433 return AsmPrinterCtorFn(TM, std::move(Streamer));
438 if (!MCDisassemblerCtorFn)
440 return MCDisassemblerCtorFn(*
this, STI, Ctx);
447 if (!MCInstPrinterCtorFn)
449 return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);
456 if (!MCCodeEmitterCtorFn)
458 return MCCodeEmitterCtorFn(II, MRI, Ctx);
470 std::unique_ptr<MCAsmBackend> &&TAB,
471 std::unique_ptr<MCObjectWriter> &&OW,
472 std::unique_ptr<MCCodeEmitter> &&Emitter,
474 bool IncrementalLinkerCompatible,
475 bool DWARFMustBeAtTheEnd)
const {
482 S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
483 std::move(Emitter), RelaxAll,
484 IncrementalLinkerCompatible);
487 if (MachOStreamerCtorFn)
488 S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
489 std::move(Emitter), RelaxAll,
490 DWARFMustBeAtTheEnd);
493 std::move(Emitter), RelaxAll,
494 DWARFMustBeAtTheEnd);
497 if (ELFStreamerCtorFn)
498 S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
499 std::move(Emitter), RelaxAll);
502 std::move(Emitter), RelaxAll);
505 if (WasmStreamerCtorFn)
506 S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
507 std::move(Emitter), RelaxAll);
510 std::move(Emitter), RelaxAll);
514 std::move(Emitter), RelaxAll);
517 if (ObjectTargetStreamerCtorFn)
518 ObjectTargetStreamerCtorFn(*S, STI);
523 std::unique_ptr<formatted_raw_ostream> OS,
524 bool IsVerboseAsm,
bool UseDwarfDirectory,
526 std::unique_ptr<MCCodeEmitter> &&CE,
527 std::unique_ptr<MCAsmBackend> &&TAB,
528 bool ShowInst)
const {
531 Ctx, std::move(OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,
532 std::move(CE), std::move(TAB), ShowInst);
540 bool IsVerboseAsm)
const {
541 if (AsmTargetStreamerCtorFn)
542 return AsmTargetStreamerCtorFn(S, OS, InstPrint, IsVerboseAsm);
553 if (NullTargetStreamerCtorFn)
554 return NullTargetStreamerCtorFn(S);
563 MCRelocationInfoCtorTy Fn = MCRelocationInfoCtorFn
564 ? MCRelocationInfoCtorFn
566 return Fn(
Triple(TT), Ctx);
585 std::unique_ptr<MCRelocationInfo> &&RelInfo)
const {
586 MCSymbolizerCtorTy Fn =
588 return Fn(
Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
604 :
public std::iterator<std::forward_iterator_tag, Target, ptrdiff_t> {
607 const Target *Current =
nullptr;
619 assert(Current &&
"Cannot increment end iterator!");
630 assert(Current &&
"Cannot dereference end iterator!");
639 static void printRegisteredTargetsForVersion(
raw_ostream &OS);
651 static const Target *lookupTarget(
const std::string &
Triple,
665 static const Target *lookupTarget(
const std::string &ArchName,
666 Triple &TheTriple, std::string &Error);
691 const char *BackendName,
693 bool HasJIT =
false);
705 T.MCAsmInfoCtorFn = Fn;
718 T.MCInstrInfoCtorFn = Fn;
725 T.MCInstrAnalysisCtorFn = Fn;
738 T.MCRegInfoCtorFn = Fn;
752 T.MCSubtargetInfoCtorFn = Fn;
765 T.TargetMachineCtorFn = Fn;
778 T.MCAsmBackendCtorFn = Fn;
791 T.MCAsmParserCtorFn = Fn;
804 T.AsmPrinterCtorFn = Fn;
818 T.MCDisassemblerCtorFn = Fn;
831 T.MCInstPrinterCtorFn = Fn;
844 T.MCCodeEmitterCtorFn = Fn;
848 T.COFFStreamerCtorFn = Fn;
852 T.MachOStreamerCtorFn = Fn;
856 T.ELFStreamerCtorFn = Fn;
860 T.WasmStreamerCtorFn = Fn;
865 T.NullTargetStreamerCtorFn = Fn;
870 T.AsmTargetStreamerCtorFn = Fn;
876 T.ObjectTargetStreamerCtorFn = Fn;
890 T.MCRelocationInfoCtorFn = Fn;
903 T.MCSymbolizerCtorFn = Fn;
927 const char *BackendName) {
933 return Arch == TargetArchType;
951 static MCAsmInfo *
Allocator(
const MCRegisterInfo & ,
953 return new MCAsmInfoImpl(TT);
985 static MCInstrInfo *
Allocator() {
return new MCInstrInfoImpl(); }
1016 static MCInstrAnalysis *
Allocator(
const MCInstrInfo *
Info) {
1017 return new MCInstrAnalysisImpl(Info);
1049 static MCRegisterInfo *
Allocator(
const Triple & ) {
1050 return new MCRegisterInfoImpl();
1082 static MCSubtargetInfo *
Allocator(
const Triple & , StringRef ,
1084 return new MCSubtargetInfoImpl();
1116 static TargetMachine *
1118 const TargetOptions &Options, Optional<Reloc::Model>
RM,
1120 return new TargetMachineImpl(T, TT, CPU, FS, Options, RM, CM, OL, JIT);
1137 static MCAsmBackend *
Allocator(
const Target &
T,
const MCSubtargetInfo &STI,
1138 const MCRegisterInfo &
MRI,
1139 const MCTargetOptions &Options) {
1140 return new MCAsmBackendImpl(T, STI, MRI);
1158 static MCTargetAsmParser *
Allocator(
const MCSubtargetInfo &STI,
1159 MCAsmParser &
P,
const MCInstrInfo &MII,
1160 const MCTargetOptions &Options) {
1161 return new MCAsmParserImpl(STI, P, MII, Options);
1180 std::unique_ptr<MCStreamer> &&Streamer) {
1181 return new AsmPrinterImpl(TM, std::move(Streamer));
1199 static MCCodeEmitter *
Allocator(
const MCInstrInfo & ,
1200 const MCRegisterInfo & ,
1202 return new MCCodeEmitterImpl();
1208 #endif // LLVM_SUPPORT_TARGETREGISTRY_H const Target * operator->() const
RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
MCTargetStreamer *(*)(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) AsmTargetStreamerCtorTy
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
Create a target specific MCStreamer.
RegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation...
This class represents lattice values for constants.
RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn)
Generic assembler parser interface, for use by target specific assembly parsers.
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM=None, CodeGenOpt::Level OL=CodeGenOpt::Default, bool JIT=false) const
createTargetMachine - Create a target specific machine implementation for the specified Triple...
bool hasTargetMachine() const
hasTargetMachine - Check if this target supports code generation.
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation...
static void RegisterMCInstrAnalysis(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target...
MCTargetAsmParser - Generic interface to target specific assembly parsers.
Superclass for all disassemblers.
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
MCCodeEmitter *(*)(const MCInstrInfo &II, const MCRegisterInfo &MRI, MCContext &Ctx) MCCodeEmitterCtorTy
MCSymbolizer *(*)(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) MCSymbolizerCtorTy
Target specific streamer interface.
MCAsmBackend * createMCAsmBackend(const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) const
createMCAsmBackend - Create a target specific assembly parser.
RegisterMCCodeEmitter(Target &T)
MCInstrInfo * createMCInstrInfo() const
createMCInstrInfo - Create a MCInstrInfo implementation.
MCSubtargetInfo *(*)(const Triple &TT, StringRef CPU, StringRef Features) MCSubtargetInfoCtorFnTy
MCStreamer * createNullStreamer(MCContext &Ctx)
Create a dummy machine code streamer, which does nothing.
RegisterMCInstrAnalysis(Target &T)
MCTargetStreamer *(*)(MCStreamer &S) NullTargetStreamerCtorTy
MCDisassembler * createMCDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx) const
static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)
RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.
TargetRegistry - Generic interface to target specific features.
static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn)
RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.
MCSymbolizer * createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo)
static void RegisterAsmTargetStreamer(Target &T, Target::AsmTargetStreamerCtorTy Fn)
RegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementat...
static void RegisterWasmStreamer(Target &T, Target::WasmStreamerCtorTy Fn)
const char * getShortDescription() const
getShortDescription - Get a short description of the target.
const char * getName() const
getName - Get the target name.
RegisterMCAsmBackend(Target &T)
RegisterTargetMachine(Target &T)
MCInstPrinter * createMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) const
MCStreamer * createXCOFFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
bool hasMCAsmParser() const
hasMCAsmParser - Check if this target supports assembly parsing.
RegisterMCRegInfoFn - Helper template for registering a target register info implementation.
static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn)
int(* LLVMOpInfoCallback)(void *DisInfo, uint64_t PC, uint64_t Offset, uint64_t Size, int TagType, void *TagBuf)
The type for the operand information call back function.
MCAsmBackend *(*)(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) MCAsmBackendCtorTy
APInt operator*(APInt a, uint64_t RHS)
MCInstrAnalysis *(*)(const MCInstrInfo *Info) MCInstrAnalysisCtorFnTy
Context object for machine code objects.
MCStreamer * createNullStreamer(MCContext &Ctx) const
MCRegisterInfo *(*)(const Triple &TT) MCRegInfoCtorFnTy
RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function.
RegisterMCAsmParser - Helper template for registering a target specific assembly parser, for use in the target machine initialization function.
static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn)
RegisterTargetMachine - Register a TargetMachine implementation for the given target.
MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint, MCCodeEmitter *CE, MCAsmBackend *TAB, bool ShowInst)
Create a machine code streamer which will print out assembly for the native target, suitable for compiling with a native assembler.
RegisterAsmPrinter - Helper template for registering a target specific assembly printer, for use in the target machine initialization function.
RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementatio...
const Target & operator*() const
MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, const MCRegisterInfo &MRI, MCContext &Ctx) const
createMCCodeEmitter - Create a target specific code emitter.
AsmPrinter *(*)(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) AsmPrinterCtorTy
Analysis containing CSE Info
MCRelocationInfo * createMCRelocationInfo(const Triple &TT, MCContext &Ctx)
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
This class is intended to be used as a base class for asm properties and features specific to the tar...
bool isOSWindows() const
Tests whether the OS is Windows.
const Target * getNext() const
static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn)
RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.
RegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation...
Streaming machine code generation interface.
MCTargetAsmParser *(*)(const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII, const MCTargetOptions &Options) MCAsmParserCtorTy
unsigned const MachineRegisterInfo * MRI
RegisterAsmPrinter(Target &T)
AsmPrinter * createAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) const
createAsmPrinter - Create a target specific assembly printer pass.
static void RegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn)
RegisterMCAsmParser - Register a MCTargetAsmParser implementation for the given target.
Symbolize and annotate disassembled instructions.
MCDisassembler *(*)(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx) MCDisassemblerCtorTy
static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn)
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCCodeEmitter - Generic instruction encoding interface.
Interface to description of machine instruction set.
RegisterMCRegInfo(Target &T)
This class is intended to be used as a driving class for all asm writers.
bool(*)(Triple::ArchType Arch) ArchMatchFnTy
static void RegisterTarget(Target &T, const char *Name, const char *ShortDesc, const char *BackendName, Target::ArchMatchFnTy ArchMatchFn, bool HasJIT=false)
RegisterTarget - Register the given target.
Create MCExprs from relocations found in an object file.
MCRegisterInfo * createMCRegInfo(StringRef TT) const
createMCRegInfo - Create a MCRegisterInfo implementation.
static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn)
RegisterMCAsmInfo - Register a MCAsmInfo implementation for the given target.
MCTargetAsmParser * createMCAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser, const MCInstrInfo &MII, const MCTargetOptions &Options) const
createMCAsmParser - Create a target specific assembly parser.
static void RegisterMCSubtargetInfo(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for the given target...
static void RegisterObjectTargetStreamer(Target &T, Target::ObjectTargetStreamerCtorTy Fn)
friend struct TargetRegistry
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
MCTargetStreamer * createAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) const
RegisterMCAsmBackend - Helper template for registering a target specific assembler backend...
MCInstrAnalysis * createMCInstrAnalysis(const MCInstrInfo *Info) const
createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
RegisterTarget(Target &T, const char *Name, const char *Desc, const char *BackendName)
static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn)
RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.
bool hasMCAsmBackend() const
hasMCAsmBackend - Check if this target supports .o generation.
MCTargetStreamer *(*)(MCStreamer &S, const MCSubtargetInfo &STI) ObjectTargetStreamerCtorTy
RegisterMCSubtargetInfo(Target &T)
RegisterMCAsmInfo(Target &T)
MCAsmInfo * createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple) const
createMCAsmInfo - Create a MCAsmInfo implementation for the specified target triple.
A range adaptor for a pair of iterators.
static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn)
RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.
Target - Wrapper for Target specific information.
RegisterMCInstrInfo(Target &T)
RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
MCAsmInfo *(*)(const MCRegisterInfo &MRI, const Triple &TT) MCAsmInfoCtorFnTy
MCSubtargetInfo * createMCSubtargetInfo(StringRef TheTriple, StringRef CPU, StringRef Features) const
createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
RegisterMCAsmParser(Target &T)
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
ObjectFormatType getObjectFormat() const
getFormat - Get the object format for this triple.
MCRelocationInfo *(*)(const Triple &TT, MCContext &Ctx) MCRelocationInfoCtorTy
static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn)
RegisterMCInstrInfo - Register a MCInstrInfo implementation for the given target. ...
Generic base class for all target subtargets.
TargetMachine *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT) TargetMachineCtorTy
MCSymbolizer * createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) const
createMCSymbolizer - Create a target specific MCSymbolizer.
static bool getArchMatch(Triple::ArchType Arch)
const char * getBackendName() const
getBackendName - Get the backend name.
static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn)
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
bool operator!=(const iterator &x) const
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll, bool DWARFMustBeAtTheEnd) MachOStreamerCtorTy
static void RegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn)
RegisterMCSymbolizer - Register an MCSymbolizer implementation for the given target.
RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
RegisterMCRegInfo - Helper template for registering a target register info implementation.
MCRelocationInfo * createMCRelocationInfo(StringRef TT, MCContext &Ctx) const
createMCRelocationInfo - Create a target specific MCRelocationInfo.
RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation.
static void RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn)
Generic interface to target specific assembler backends.
RegisterMCAsmInfo - Helper template for registering a target assembly info implementation.
bool hasJIT() const
hasJIT - Check if this targets supports the just-in-time compilation.
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) ELFStreamerCtorTy
Lightweight error class with error context and mandatory checking.
MCTargetStreamer * createNullTargetStreamer(MCStreamer &S) const
static void RegisterMCRelocationInfo(Target &T, Target::MCRelocationInfoCtorTy Fn)
RegisterMCRelocationInfo - Register an MCRelocationInfo implementation for the given target...
This class implements an extremely fast bulk output stream that can only output to a stream...
MCInstPrinter *(*)(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) MCInstPrinterCtorTy
Primary interface to the complete machine description for the target machine.
static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn)
RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.
MCStreamer * createWasmStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCInstrInfo *(*)() MCInstrInfoCtorFnTy
StringRef - Represent a constant reference to a string, i.e.
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) WasmStreamerCtorTy
bool operator==(uint64_t V1, const APInt &V2)
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)
const char *(* LLVMSymbolLookupCallback)(void *DisInfo, uint64_t ReferenceValue, uint64_t *ReferenceType, uint64_t ReferencePC, const char **ReferenceName)
The type for the symbol lookup function.
bool operator==(const iterator &x) const
RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter...
RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn)
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll, bool IncrementalLinkerCompatible) COFFStreamerCtorTy
RegisterMCInstrInfo - Helper template for registering a target instruction info implementation.