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);
97 std::unique_ptr<MCAsmBackend> &&TAB,
98 std::unique_ptr<MCObjectWriter> &&OW,
99 std::unique_ptr<MCCodeEmitter> &&CE);
101 std::unique_ptr<MCAsmBackend> &&TAB,
102 std::unique_ptr<MCObjectWriter> &&OW,
103 std::unique_ptr<MCCodeEmitter> &&CE,
104 bool DWARFMustBeAtTheEnd,
105 bool LabelSections =
false);
107 std::unique_ptr<MCAsmBackend> &&TAB,
108 std::unique_ptr<MCObjectWriter> &&OW,
109 std::unique_ptr<MCCodeEmitter> &&CE);
111 std::unique_ptr<MCAsmBackend> &&TAB,
112 std::unique_ptr<MCObjectWriter> &&OW,
113 std::unique_ptr<MCCodeEmitter> &&CE);
115 std::unique_ptr<MCAsmBackend> &&TAB,
116 std::unique_ptr<MCObjectWriter> &&OW,
117 std::unique_ptr<MCCodeEmitter> &&CE);
119 std::unique_ptr<MCAsmBackend> &&TAB,
120 std::unique_ptr<MCObjectWriter> &&OW,
121 std::unique_ptr<MCCodeEmitter> &&CE);
128 std::unique_ptr<MCRelocationInfo> &&RelInfo);
159 bool LargeCodeModel);
186 unsigned SyntaxVariant,
194 std::unique_ptr<MCAsmBackend> &&TAB,
195 std::unique_ptr<MCObjectWriter> &&OW,
196 std::unique_ptr<MCCodeEmitter> &&
Emitter);
199 std::unique_ptr<MCObjectWriter> &&OW,
200 std::unique_ptr<MCCodeEmitter> &&
Emitter);
203 std::unique_ptr<MCObjectWriter> &&OW,
204 std::unique_ptr<MCCodeEmitter> &&
Emitter,
205 bool DWARFMustBeAtTheEnd);
208 std::unique_ptr<MCObjectWriter> &&OW,
209 std::unique_ptr<MCCodeEmitter> &&
Emitter,
210 bool IncrementalLinkerCompatible);
213 std::unique_ptr<MCAsmBackend> &&TAB,
214 std::unique_ptr<MCObjectWriter> &&OW,
215 std::unique_ptr<MCCodeEmitter> &&
Emitter);
218 std::unique_ptr<MCAsmBackend> &&TAB,
219 std::unique_ptr<MCObjectWriter> &&OW,
220 std::unique_ptr<MCCodeEmitter> &&
Emitter);
223 std::unique_ptr<MCAsmBackend> &&TAB,
224 std::unique_ptr<MCObjectWriter> &&OW,
225 std::unique_ptr<MCCodeEmitter> &&
Emitter);
229 std::unique_ptr<MCAsmBackend> &&TAB,
230 std::unique_ptr<MCObjectWriter> &&OW,
231 std::unique_ptr<MCCodeEmitter> &&
Emitter);
244 std::unique_ptr<MCRelocationInfo> &&RelInfo);
271 const char *ShortDesc;
275 const char *BackendName;
420 if (!MCAsmInfoCtorFn)
429 bool LargeCodeModel =
false)
const {
430 if (!MCObjectFileInfoCtorFn) {
435 return MCObjectFileInfoCtorFn(Ctx,
PIC, LargeCodeModel);
441 if (!MCInstrInfoCtorFn)
443 return MCInstrInfoCtorFn();
449 if (!MCInstrAnalysisCtorFn)
451 return MCInstrAnalysisCtorFn(
Info);
457 if (!MCRegInfoCtorFn)
459 return MCRegInfoCtorFn(
Triple(TT));
473 if (!MCSubtargetInfoCtorFn)
475 return MCSubtargetInfoCtorFn(
Triple(TheTriple), CPU, Features);
488 std::optional<CodeModel::Model> CM = std::nullopt,
490 if (!TargetMachineCtorFn)
492 return TargetMachineCtorFn(*
this,
Triple(TT), CPU, Features,
Options, RM,
500 if (!MCAsmBackendCtorFn)
502 return MCAsmBackendCtorFn(*
this, STI,
MRI,
Options);
513 if (!MCAsmParserCtorFn)
515 return MCAsmParserCtorFn(STI, Parser, MII,
Options);
521 std::unique_ptr<MCStreamer> &&Streamer)
const {
522 if (!AsmPrinterCtorFn)
524 return AsmPrinterCtorFn(
TM, std::move(Streamer));
529 if (!MCDisassemblerCtorFn)
531 return MCDisassemblerCtorFn(*
this, STI, Ctx);
538 if (!MCInstPrinterCtorFn)
540 return MCInstPrinterCtorFn(
T, SyntaxVariant, MAI, MII,
MRI);
546 if (!MCCodeEmitterCtorFn)
548 return MCCodeEmitterCtorFn(II, Ctx);
560 std::unique_ptr<MCAsmBackend> &&TAB,
561 std::unique_ptr<MCObjectWriter> &&OW,
562 std::unique_ptr<MCCodeEmitter> &&
Emitter,
564 bool IncrementalLinkerCompatible,
565 bool DWARFMustBeAtTheEnd)
const {
567 switch (
T.getObjectFormat()) {
571 assert((
T.isOSWindows() ||
T.isUEFI()) &&
572 "only Windows and UEFI COFF are supported");
573 S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
574 std::move(
Emitter), IncrementalLinkerCompatible);
577 if (MachOStreamerCtorFn)
578 S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
579 std::move(
Emitter), DWARFMustBeAtTheEnd);
582 std::move(
Emitter), DWARFMustBeAtTheEnd);
585 if (ELFStreamerCtorFn)
586 S = ELFStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
593 if (WasmStreamerCtorFn)
594 S = WasmStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
601 if (GOFFStreamerCtorFn)
602 S = GOFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
609 if (XCOFFStreamerCtorFn)
610 S = XCOFFStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
617 if (SPIRVStreamerCtorFn)
618 S = SPIRVStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
625 if (DXContainerStreamerCtorFn)
626 S = DXContainerStreamerCtorFn(
T, Ctx, std::move(TAB), std::move(OW),
633 if (ObjectTargetStreamerCtorFn)
634 ObjectTargetStreamerCtorFn(*S, STI);
639 std::unique_ptr<formatted_raw_ostream>
OS,
640 bool IsVerboseAsm,
bool UseDwarfDirectory,
642 std::unique_ptr<MCCodeEmitter> &&CE,
643 std::unique_ptr<MCAsmBackend> &&TAB,
644 bool ShowInst)
const {
647 Ctx, std::move(
OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,
648 std::move(CE), std::move(TAB), ShowInst);
656 bool IsVerboseAsm)
const {
657 if (AsmTargetStreamerCtorFn)
658 return AsmTargetStreamerCtorFn(S,
OS, InstPrint, IsVerboseAsm);
669 if (NullTargetStreamerCtorFn)
670 return NullTargetStreamerCtorFn(S);
680 ? MCRelocationInfoCtorFn
682 return Fn(
Triple(TT), Ctx);
701 std::unique_ptr<MCRelocationInfo> &&RelInfo)
const {
704 return Fn(
Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
713 if (CustomBehaviourCtorFn)
714 return CustomBehaviourCtorFn(STI,
SrcMgr, MCII);
722 if (InstrPostProcessCtorFn)
723 return InstrPostProcessCtorFn(STI, MCII);
733 if (InstrumentManagerCtorFn)
734 return InstrumentManagerCtorFn(STI, MCII);
752 const Target *Current =
nullptr;
770 assert(Current &&
"Cannot increment end iterator!");
781 assert(Current &&
"Cannot dereference end iterator!");
841 const char *BackendName,
843 bool HasJIT =
false);
855 T.MCAsmInfoCtorFn = Fn;
868 T.MCObjectFileInfoCtorFn = Fn;
881 T.MCInstrInfoCtorFn = Fn;
888 T.MCInstrAnalysisCtorFn = Fn;
901 T.MCRegInfoCtorFn = Fn;
915 T.MCSubtargetInfoCtorFn = Fn;
928 T.TargetMachineCtorFn = Fn;
941 T.MCAsmBackendCtorFn = Fn;
954 T.MCAsmParserCtorFn = Fn;
967 T.AsmPrinterCtorFn = Fn;
981 T.MCDisassemblerCtorFn = Fn;
994 T.MCInstPrinterCtorFn = Fn;
1007 T.MCCodeEmitterCtorFn = Fn;
1011 T.COFFStreamerCtorFn = Fn;
1015 T.GOFFStreamerCtorFn = Fn;
1019 T.MachOStreamerCtorFn = Fn;
1023 T.ELFStreamerCtorFn = Fn;
1027 T.SPIRVStreamerCtorFn = Fn;
1031 T.DXContainerStreamerCtorFn = Fn;
1035 T.WasmStreamerCtorFn = Fn;
1039 T.XCOFFStreamerCtorFn = Fn;
1044 T.NullTargetStreamerCtorFn = Fn;
1049 T.AsmTargetStreamerCtorFn = Fn;
1055 T.ObjectTargetStreamerCtorFn = Fn;
1069 T.MCRelocationInfoCtorFn = Fn;
1082 T.MCSymbolizerCtorFn = Fn;
1096 T.CustomBehaviourCtorFn = Fn;
1110 T.InstrPostProcessCtorFn = Fn;
1125 T.InstrumentManagerCtorFn = Fn;
1146 bool HasJIT =
false>
1149 const char *BackendName) {
1155 return Arch == TargetArchType;
1175 return new MCAsmInfoImpl(TT,
Options);
1208 bool LargeCodeModel =
false) {
1209 return new MCObjectFileInfoImpl(Ctx,
PIC, LargeCodeModel);
1240 static MCInstrInfo *Allocator() {
return new MCInstrInfoImpl(); }
1272 return new MCInstrAnalysisImpl(
Info);
1305 return new MCRegisterInfoImpl();
1339 return new MCSubtargetInfoImpl();
1375 return new TargetMachineImpl(
T, TT, CPU, FS,
Options, RM, CM, OL, JIT);
1395 return new MCAsmBackendImpl(
T, STI,
MRI);
1416 return new MCAsmParserImpl(STI,
P, MII,
Options);
1435 std::unique_ptr<MCStreamer> &&Streamer) {
1436 return new AsmPrinterImpl(
TM, std::move(Streamer));
1456 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
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) XCOFFStreamerCtorTy
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.
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.
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) GOFFStreamerCtorTy
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) ELFStreamerCtorTy
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.
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) WasmStreamerCtorTy
bool(*)(Triple::ArchType Arch) ArchMatchFnTy
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.
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, bool IncrementalLinkerCompatible, bool DWARFMustBeAtTheEnd) const
Create a target specific MCStreamer.
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 *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) DXContainerStreamerCtorTy
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.
const char * getBackendName() const
getBackendName - Get the backend name.
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.
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool DWARFMustBeAtTheEnd) MachOStreamerCtorTy
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
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) SPIRVStreamerCtorTy
mca::InstrumentManager *(*)(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) InstrumentManagerCtorTy
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool IncrementalLinkerCompatible) COFFStreamerCtorTy
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
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.
mca::CustomBehaviour * createCustomBehaviour(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII)
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)
MCStreamer * createXCOFFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)
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 * createMachOStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool DWARFMustBeAtTheEnd, bool LabelSections=false)
MCRelocationInfo * createMCRelocationInfo(const Triple &TT, MCContext &Ctx)
CodeGenOptLevel
Code generation optimization level.
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,...
MCStreamer * createDXContainerStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)
mca::InstrumentManager * createInstrumentManager(const MCSubtargetInfo &STI, const MCInstrInfo &MCII)
MCStreamer * createWasmStreamer(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 * createSPIRVStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)
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 ...