18#ifndef LLVM_MC_TARGETREGISTRY_H
19#define LLVM_MC_TARGETREGISTRY_H
50class MCRelocationInfo;
54class MCTargetAsmParser;
56class MCTargetStreamer;
88 bool isVerboseAsm,
bool useDwarfDirectory,
89 MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,
90 std::unique_ptr<MCAsmBackend> &&TAB,
bool ShowInst);
93 std::unique_ptr<MCAsmBackend> &&TAB,
94 std::unique_ptr<MCObjectWriter> &&OW,
95 std::unique_ptr<MCCodeEmitter> &&CE,
98 std::unique_ptr<MCAsmBackend> &&TAB,
99 std::unique_ptr<MCObjectWriter> &&OW,
100 std::unique_ptr<MCCodeEmitter> &&CE,
103 std::unique_ptr<MCAsmBackend> &&TAB,
104 std::unique_ptr<MCObjectWriter> &&OW,
105 std::unique_ptr<MCCodeEmitter> &&CE,
106 bool RelaxAll,
bool DWARFMustBeAtTheEnd,
107 bool LabelSections =
false);
109 std::unique_ptr<MCAsmBackend> &&TAB,
110 std::unique_ptr<MCObjectWriter> &&OW,
111 std::unique_ptr<MCCodeEmitter> &&CE,
114 std::unique_ptr<MCAsmBackend> &&TAB,
115 std::unique_ptr<MCObjectWriter> &&OW,
116 std::unique_ptr<MCCodeEmitter> &&CE,
119 std::unique_ptr<MCAsmBackend> &&TAB,
120 std::unique_ptr<MCObjectWriter> &&OW,
121 std::unique_ptr<MCCodeEmitter> &&CE,
124 std::unique_ptr<MCAsmBackend> &&TAB,
125 std::unique_ptr<MCObjectWriter> &&OW,
126 std::unique_ptr<MCCodeEmitter> &&CE,
134 std::unique_ptr<MCRelocationInfo> &&RelInfo);
165 bool LargeCodeModel);
192 unsigned SyntaxVariant,
200 std::unique_ptr<MCAsmBackend> &&TAB,
201 std::unique_ptr<MCObjectWriter> &&OW,
202 std::unique_ptr<MCCodeEmitter> &&
Emitter,
bool RelaxAll);
205 std::unique_ptr<MCObjectWriter> &&OW,
206 std::unique_ptr<MCCodeEmitter> &&
Emitter,
bool RelaxAll);
209 std::unique_ptr<MCObjectWriter> &&OW,
210 std::unique_ptr<MCCodeEmitter> &&
Emitter,
bool RelaxAll,
211 bool DWARFMustBeAtTheEnd);
214 std::unique_ptr<MCObjectWriter> &&OW,
215 std::unique_ptr<MCCodeEmitter> &&
Emitter,
bool RelaxAll,
216 bool IncrementalLinkerCompatible);
219 std::unique_ptr<MCAsmBackend> &&TAB,
220 std::unique_ptr<MCObjectWriter> &&OW,
221 std::unique_ptr<MCCodeEmitter> &&
Emitter,
bool RelaxAll);
224 std::unique_ptr<MCAsmBackend> &&TAB,
225 std::unique_ptr<MCObjectWriter> &&OW,
226 std::unique_ptr<MCCodeEmitter> &&
Emitter,
bool RelaxAll);
229 std::unique_ptr<MCAsmBackend> &&TAB,
230 std::unique_ptr<MCObjectWriter> &&OW,
231 std::unique_ptr<MCCodeEmitter> &&
Emitter,
bool RelaxAll);
235 std::unique_ptr<MCAsmBackend> &&TAB,
236 std::unique_ptr<MCObjectWriter> &&OW,
237 std::unique_ptr<MCCodeEmitter> &&
Emitter,
bool RelaxAll);
250 std::unique_ptr<MCRelocationInfo> &&RelInfo);
277 const char *ShortDesc;
281 const char *BackendName;
426 if (!MCAsmInfoCtorFn)
435 bool LargeCodeModel =
false)
const {
436 if (!MCObjectFileInfoCtorFn) {
441 return MCObjectFileInfoCtorFn(Ctx,
PIC, LargeCodeModel);
447 if (!MCInstrInfoCtorFn)
449 return MCInstrInfoCtorFn();
455 if (!MCInstrAnalysisCtorFn)
457 return MCInstrAnalysisCtorFn(
Info);
463 if (!MCRegInfoCtorFn)
465 return MCRegInfoCtorFn(
Triple(TT));
479 if (!MCSubtargetInfoCtorFn)
481 return MCSubtargetInfoCtorFn(
Triple(TheTriple), CPU, Features);
494 std::optional<CodeModel::Model> CM = std::nullopt,
496 if (!TargetMachineCtorFn)
498 return TargetMachineCtorFn(*
this,
Triple(TT), CPU, Features,
Options, RM,
506 if (!MCAsmBackendCtorFn)
508 return MCAsmBackendCtorFn(*
this, STI,
MRI,
Options);
519 if (!MCAsmParserCtorFn)
521 return MCAsmParserCtorFn(STI, Parser, MII,
Options);
527 std::unique_ptr<MCStreamer> &&Streamer)
const {
528 if (!AsmPrinterCtorFn)
530 return AsmPrinterCtorFn(
TM, std::move(Streamer));
535 if (!MCDisassemblerCtorFn)
537 return MCDisassemblerCtorFn(*
this, STI, Ctx);
544 if (!MCInstPrinterCtorFn)
546 return MCInstPrinterCtorFn(
T, SyntaxVariant, MAI, MII,
MRI);
552 if (!MCCodeEmitterCtorFn)
554 return MCCodeEmitterCtorFn(II, Ctx);
566 std::unique_ptr<MCAsmBackend> &&TAB,
567 std::unique_ptr<MCObjectWriter> &&OW,
568 std::unique_ptr<MCCodeEmitter> &&
Emitter,
570 bool IncrementalLinkerCompatible,
571 bool DWARFMustBeAtTheEnd)
const {
573 switch (
T.getObjectFormat()) {
577 assert((
T.isOSWindows() ||
T.isUEFI()) &&
578 "only Windows and UEFI COFF are supported");
579 S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
581 IncrementalLinkerCompatible);
584 if (MachOStreamerCtorFn)
585 S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
587 DWARFMustBeAtTheEnd);
591 DWARFMustBeAtTheEnd);
594 if (ELFStreamerCtorFn)
595 S = ELFStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
602 if (WasmStreamerCtorFn)
603 S = WasmStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
610 if (GOFFStreamerCtorFn)
611 S = GOFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
618 if (XCOFFStreamerCtorFn)
619 S = XCOFFStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
626 if (SPIRVStreamerCtorFn)
627 S = SPIRVStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
634 if (DXContainerStreamerCtorFn)
635 S = DXContainerStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
642 if (ObjectTargetStreamerCtorFn)
643 ObjectTargetStreamerCtorFn(*S, STI);
648 std::unique_ptr<formatted_raw_ostream>
OS,
649 bool IsVerboseAsm,
bool UseDwarfDirectory,
651 std::unique_ptr<MCCodeEmitter> &&CE,
652 std::unique_ptr<MCAsmBackend> &&TAB,
653 bool ShowInst)
const {
656 Ctx, std::move(
OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,
657 std::move(CE), std::move(TAB), ShowInst);
665 bool IsVerboseAsm)
const {
666 if (AsmTargetStreamerCtorFn)
667 return AsmTargetStreamerCtorFn(S,
OS, InstPrint, IsVerboseAsm);
678 if (NullTargetStreamerCtorFn)
679 return NullTargetStreamerCtorFn(S);
689 ? MCRelocationInfoCtorFn
691 return Fn(
Triple(TT), Ctx);
710 std::unique_ptr<MCRelocationInfo> &&RelInfo)
const {
713 return Fn(
Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
722 if (CustomBehaviourCtorFn)
723 return CustomBehaviourCtorFn(STI,
SrcMgr, MCII);
731 if (InstrPostProcessCtorFn)
732 return InstrPostProcessCtorFn(STI, MCII);
742 if (InstrumentManagerCtorFn)
743 return InstrumentManagerCtorFn(STI, MCII);
761 const Target *Current =
nullptr;
779 assert(Current &&
"Cannot increment end iterator!");
790 assert(Current &&
"Cannot dereference end iterator!");
850 const char *BackendName,
852 bool HasJIT =
false);
864 T.MCAsmInfoCtorFn = Fn;
877 T.MCObjectFileInfoCtorFn = Fn;
890 T.MCInstrInfoCtorFn = Fn;
897 T.MCInstrAnalysisCtorFn = Fn;
910 T.MCRegInfoCtorFn = Fn;
924 T.MCSubtargetInfoCtorFn = Fn;
937 T.TargetMachineCtorFn = Fn;
950 T.MCAsmBackendCtorFn = Fn;
963 T.MCAsmParserCtorFn = Fn;
976 T.AsmPrinterCtorFn = Fn;
990 T.MCDisassemblerCtorFn = Fn;
1003 T.MCInstPrinterCtorFn = Fn;
1016 T.MCCodeEmitterCtorFn = Fn;
1020 T.COFFStreamerCtorFn = Fn;
1024 T.GOFFStreamerCtorFn = Fn;
1028 T.MachOStreamerCtorFn = Fn;
1032 T.ELFStreamerCtorFn = Fn;
1036 T.SPIRVStreamerCtorFn = Fn;
1040 T.DXContainerStreamerCtorFn = Fn;
1044 T.WasmStreamerCtorFn = Fn;
1048 T.XCOFFStreamerCtorFn = Fn;
1053 T.NullTargetStreamerCtorFn = Fn;
1058 T.AsmTargetStreamerCtorFn = Fn;
1064 T.ObjectTargetStreamerCtorFn = Fn;
1078 T.MCRelocationInfoCtorFn = Fn;
1091 T.MCSymbolizerCtorFn = Fn;
1105 T.CustomBehaviourCtorFn = Fn;
1119 T.InstrPostProcessCtorFn = Fn;
1134 T.InstrumentManagerCtorFn = Fn;
1155 bool HasJIT =
false>
1158 const char *BackendName) {
1164 return Arch == TargetArchType;
1184 return new MCAsmInfoImpl(TT,
Options);
1217 bool LargeCodeModel =
false) {
1218 return new MCObjectFileInfoImpl(Ctx,
PIC, LargeCodeModel);
1249 static MCInstrInfo *Allocator() {
return new MCInstrInfoImpl(); }
1281 return new MCInstrAnalysisImpl(
Info);
1314 return new MCRegisterInfoImpl();
1348 return new MCSubtargetInfoImpl();
1384 return new TargetMachineImpl(
T, TT, CPU, FS,
Options, RM, CM, OL, JIT);
1404 return new MCAsmBackendImpl(
T, STI,
MRI);
1425 return new MCAsmParserImpl(STI,
P, MII,
Options);
1444 std::unique_ptr<MCStreamer> &&Streamer) {
1445 return new AsmPrinterImpl(
TM, std::move(Streamer));
1465 return new MCCodeEmitterImpl();
unsigned const MachineRegisterInfo * MRI
Analysis containing CSE Info
dxil DXContainer Global Emitter
const char LLVMTargetMachineRef TM
PassInstrumentationCallbacks PIC
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class is intended to be used as a driving class for all asm writers.
Lightweight error class with error context and mandatory checking.
Generic interface to target specific assembler backends.
This class is intended to be used as a base class for asm properties and features specific to the tar...
Generic assembler parser interface, for use by target specific assembly parsers.
MCCodeEmitter - Generic instruction encoding interface.
Context object for machine code objects.
Superclass for all disassemblers.
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Interface to description of machine instruction set.
void initMCObjectFileInfo(MCContext &MCCtx, bool PIC, bool LargeCodeModel=false)
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Create MCExprs from relocations found in an object file.
Streaming machine code generation interface.
Generic base class for all target subtargets.
Symbolize and annotate disassembled instructions.
MCTargetAsmParser - Generic interface to target specific assembly parsers.
Target specific streamer interface.
StringRef - Represent a constant reference to a string, i.e.
Primary interface to the complete machine description for the target machine.
bool operator!=(const iterator &x) const
const Target * operator->() const
bool operator==(const iterator &x) const
const Target & operator*() const
std::ptrdiff_t difference_type
std::forward_iterator_tag iterator_category
Target - Wrapper for Target specific information.
MCTargetStreamer *(*)(MCStreamer &S) NullTargetStreamerCtorTy
MCDisassembler *(*)(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx) MCDisassemblerCtorTy
mca::InstrPostProcess *(*)(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) InstrPostProcessCtorTy
MCAsmInfo *(*)(const MCRegisterInfo &MRI, const Triple &TT, const MCTargetOptions &Options) MCAsmInfoCtorFnTy
bool hasTargetMachine() const
hasTargetMachine - Check if this target supports code generation.
TargetMachine *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM, CodeGenOptLevel OL, bool JIT) TargetMachineCtorTy
MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, MCContext &Ctx) const
createMCCodeEmitter - Create a target specific code emitter.
const char * getName() const
getName - Get the target name.
MCObjectFileInfo * createMCObjectFileInfo(MCContext &Ctx, bool PIC, bool LargeCodeModel=false) const
Create a MCObjectFileInfo implementation for the specified target triple.
const Target * getNext() const
MCSubtargetInfo * createMCSubtargetInfo(StringRef TheTriple, StringRef CPU, StringRef Features) const
createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
AsmPrinter *(*)(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) AsmPrinterCtorTy
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
MCSymbolizer * createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) const
createMCSymbolizer - Create a target specific MCSymbolizer.
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) GOFFStreamerCtorTy
MCAsmBackend * createMCAsmBackend(const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) const
createMCAsmBackend - Create a target specific assembly parser.
MCObjectFileInfo *(*)(MCContext &Ctx, bool PIC, bool LargeCodeModel) MCObjectFileInfoCtorFnTy
bool hasMCAsmParser() const
hasMCAsmParser - Check if this target supports assembly parsing.
MCStreamer * createNullStreamer(MCContext &Ctx) const
MCRelocationInfo * createMCRelocationInfo(StringRef TT, MCContext &Ctx) const
createMCRelocationInfo - Create a target specific MCRelocationInfo.
MCInstrAnalysis *(*)(const MCInstrInfo *Info) MCInstrAnalysisCtorFnTy
MCRegisterInfo * createMCRegInfo(StringRef TT) const
createMCRegInfo - Create a MCRegisterInfo implementation.
MCTargetStreamer *(*)(MCStreamer &S, const MCSubtargetInfo &STI) ObjectTargetStreamerCtorTy
MCRegisterInfo *(*)(const Triple &TT) MCRegInfoCtorFnTy
MCInstrInfo *(*)() MCInstrInfoCtorFnTy
MCTargetStreamer *(*)(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) AsmTargetStreamerCtorTy
mca::CustomBehaviour * createCustomBehaviour(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII) const
createCustomBehaviour - Create a target specific CustomBehaviour.
bool(*)(Triple::ArchType Arch) ArchMatchFnTy
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) ELFStreamerCtorTy
MCInstPrinter *(*)(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) MCInstPrinterCtorTy
MCDisassembler * createMCDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx) const
mca::CustomBehaviour *(*)(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII) CustomBehaviourCtorTy
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM=std::nullopt, CodeGenOptLevel OL=CodeGenOptLevel::Default, bool JIT=false) const
createTargetMachine - Create a target specific machine implementation for the specified Triple.
bool hasMCAsmBackend() const
hasMCAsmBackend - Check if this target supports .o generation.
MCAsmInfo * createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple, const MCTargetOptions &Options) const
createMCAsmInfo - Create a MCAsmInfo implementation for the specified target triple.
MCInstPrinter * createMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) const
MCSymbolizer *(*)(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) MCSymbolizerCtorTy
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll, bool DWARFMustBeAtTheEnd) MachOStreamerCtorTy
MCSubtargetInfo *(*)(const Triple &TT, StringRef CPU, StringRef Features) MCSubtargetInfoCtorFnTy
mca::InstrPostProcess * createInstrPostProcess(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) const
createInstrPostProcess - Create a target specific InstrPostProcess.
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.
const char * getBackendName() const
getBackendName - Get the backend name.
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) SPIRVStreamerCtorTy
MCAsmBackend *(*)(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) MCAsmBackendCtorTy
MCTargetAsmParser * createMCAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser, const MCInstrInfo &MII, const MCTargetOptions &Options) const
createMCAsmParser - Create a target specific assembly parser.
MCInstrAnalysis * createMCInstrAnalysis(const MCInstrInfo *Info) const
createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
const char * getShortDescription() const
getShortDescription - Get a short description of the target.
bool hasJIT() const
hasJIT - Check if this targets supports the just-in-time compilation.
MCCodeEmitter *(*)(const MCInstrInfo &II, MCContext &Ctx) MCCodeEmitterCtorTy
MCTargetStreamer * createAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) const
mca::InstrumentManager *(*)(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) InstrumentManagerCtorTy
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) WasmStreamerCtorTy
MCTargetStreamer * createNullTargetStreamer(MCStreamer &S) const
MCRelocationInfo *(*)(const Triple &TT, MCContext &Ctx) MCRelocationInfoCtorTy
MCTargetAsmParser *(*)(const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII, const MCTargetOptions &Options) MCAsmParserCtorTy
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll, bool IncrementalLinkerCompatible) COFFStreamerCtorTy
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) XCOFFStreamerCtorTy
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) DXContainerStreamerCtorTy
AsmPrinter * createAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) const
createAsmPrinter - Create a target specific assembly printer pass.
MCInstrInfo * createMCInstrInfo() const
createMCInstrInfo - Create a MCInstrInfo implementation.
mca::InstrumentManager * createInstrumentManager(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) const
createInstrumentManager - Create a target specific InstrumentManager.
Triple - Helper class for working with autoconf configuration names.
A range adaptor for a pair of iterators.
Class which can be overriden by targets to enforce instruction dependencies and behaviours that aren'...
Class which can be overriden by targets to modify the mca::Instruction objects before the pipeline st...
This class allows targets to optionally customize the logic that resolves scheduling class IDs.
This class implements an extremely fast bulk output stream that can only output to a stream.
const char *(* LLVMSymbolLookupCallback)(void *DisInfo, uint64_t ReferenceValue, uint64_t *ReferenceType, uint64_t ReferencePC, const char **ReferenceName)
The type for the symbol lookup function.
int(* LLVMOpInfoCallback)(void *DisInfo, uint64_t PC, uint64_t Offset, uint64_t OpSize, uint64_t InstSize, int TagType, void *TagBuf)
The type for the operand information call back function.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
MCStreamer * createSPIRVStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
mca::CustomBehaviour * createCustomBehaviour(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII)
MCStreamer * createNullStreamer(MCContext &Ctx)
Create a dummy machine code streamer, which does nothing.
MCSymbolizer * createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo)
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)
MCStreamer * createXCOFFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
CodeGenOptLevel
Code generation optimization level.
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 * createGOFFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCStreamer * createWasmStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
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)
Create a machine code streamer which will print out assembly for the native target,...
mca::InstrumentManager * createInstrumentManager(const MCSubtargetInfo &STI, const MCInstrInfo &MCII)
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
mca::InstrPostProcess * createInstrPostProcess(const MCSubtargetInfo &STI, const MCInstrInfo &MCII)
Description of the encoding of one expression Op.
RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...
RegisterAsmPrinter(Target &T)
RegisterMCAsmBackend - Helper template for registering a target specific assembler backend.
RegisterMCAsmBackend(Target &T)
RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation.
RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn)
RegisterMCAsmInfo - Helper template for registering a target assembly info implementation.
RegisterMCAsmInfo(Target &T)
RegisterMCAsmParser - Helper template for registering a target specific assembly parser,...
RegisterMCAsmParser(Target &T)
RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter,...
RegisterMCCodeEmitter(Target &T)
RegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementat...
RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementatio...
RegisterMCInstrAnalysis(Target &T)
RegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation.
RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn)
RegisterMCInstrInfo - Helper template for registering a target instruction info implementation.
RegisterMCInstrInfo(Target &T)
Helper template for registering a target object file info implementation.
RegisterMCObjectFileInfoFn(Target &T, Target::MCObjectFileInfoCtorFnTy Fn)
Helper template for registering a target object file info implementation.
RegisterMCObjectFileInfo(Target &T)
RegisterMCRegInfoFn - Helper template for registering a target register info implementation.
RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn)
RegisterMCRegInfo - Helper template for registering a target register info implementation.
RegisterMCRegInfo(Target &T)
RegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation.
RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation.
RegisterMCSubtargetInfo(Target &T)
RegisterTargetMachine - Helper template for registering a target machine implementation,...
RegisterTargetMachine(Target &T)
RegisterTarget - Helper template for registering a target, for use in the target's initialization fun...
static bool getArchMatch(Triple::ArchType Arch)
RegisterTarget(Target &T, const char *Name, const char *Desc, const char *BackendName)
TargetRegistry - Generic interface to target specific features.
static void RegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn)
RegisterMCSymbolizer - Register an MCSymbolizer implementation for the given target.
static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn)
RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.
static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn)
RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.
static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn)
RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.
static void RegisterXCOFFStreamer(Target &T, Target::XCOFFStreamerCtorTy Fn)
static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn)
RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.
static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn)
RegisterMCAsmInfo - Register a MCAsmInfo implementation for the given target.
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)
static void RegisterMCInstrAnalysis(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target.
static void RegisterSPIRVStreamer(Target &T, Target::SPIRVStreamerCtorTy Fn)
static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn)
static void RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn)
static void RegisterInstrPostProcess(Target &T, Target::InstrPostProcessCtorTy Fn)
RegisterInstrPostProcess - Register an InstrPostProcess implementation for the given target.
static const Target * lookupTarget(StringRef Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)
RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.
static void RegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn)
RegisterMCAsmParser - Register a MCTargetAsmParser implementation for the given target.
static void printRegisteredTargetsForVersion(raw_ostream &OS)
printRegisteredTargetsForVersion - Print the registered targets appropriately for inclusion in a tool...
static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn)
RegisterTargetMachine - Register a TargetMachine implementation for the given target.
static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn)
RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.
static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn)
static void RegisterDXContainerStreamer(Target &T, Target::DXContainerStreamerCtorTy Fn)
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.
static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn)
RegisterMCInstrInfo - Register a MCInstrInfo implementation for the given target.
static void RegisterWasmStreamer(Target &T, Target::WasmStreamerCtorTy Fn)
static iterator_range< iterator > targets()
static void RegisterGOFFStreamer(Target &T, Target::GOFFStreamerCtorTy Fn)
static void RegisterInstrumentManager(Target &T, Target::InstrumentManagerCtorTy Fn)
RegisterInstrumentManager - Register an InstrumentManager implementation for the given target.
static void RegisterCustomBehaviour(Target &T, Target::CustomBehaviourCtorTy Fn)
RegisterCustomBehaviour - Register a CustomBehaviour implementation for the given target.
static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn)
static void RegisterMCObjectFileInfo(Target &T, Target::MCObjectFileInfoCtorFnTy Fn)
Register a MCObjectFileInfo implementation for the given target.
static void RegisterAsmTargetStreamer(Target &T, Target::AsmTargetStreamerCtorTy Fn)
static void RegisterMCRelocationInfo(Target &T, Target::MCRelocationInfoCtorTy Fn)
RegisterMCRelocationInfo - Register an MCRelocationInfo implementation for the given target.
Abstracting the input code sequence (a sequence of MCInst) and assigning unique identifiers to every ...