Go to the documentation of this file.
18 #ifndef LLVM_MC_TARGETREGISTRY_H
19 #define LLVM_MC_TARGETREGISTRY_H
46 class MCInstrAnalysis;
50 class MCRelocationInfo;
52 class MCSubtargetInfo;
54 class MCTargetAsmParser;
55 class MCTargetOptions;
56 class MCTargetStreamer;
87 bool isVerboseAsm,
bool useDwarfDirectory,
88 MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,
89 std::unique_ptr<MCAsmBackend> &&TAB,
bool ShowInst);
92 std::unique_ptr<MCAsmBackend> &&TAB,
93 std::unique_ptr<MCObjectWriter> &&OW,
94 std::unique_ptr<MCCodeEmitter> &&CE,
97 std::unique_ptr<MCAsmBackend> &&TAB,
98 std::unique_ptr<MCObjectWriter> &&OW,
99 std::unique_ptr<MCCodeEmitter> &&CE,
100 bool RelaxAll,
bool DWARFMustBeAtTheEnd,
101 bool LabelSections =
false);
103 std::unique_ptr<MCAsmBackend> &&TAB,
104 std::unique_ptr<MCObjectWriter> &&OW,
105 std::unique_ptr<MCCodeEmitter> &&CE,
108 std::unique_ptr<MCAsmBackend> &&TAB,
109 std::unique_ptr<MCObjectWriter> &&OW,
110 std::unique_ptr<MCCodeEmitter> &&CE,
113 std::unique_ptr<MCAsmBackend> &&TAB,
114 std::unique_ptr<MCObjectWriter> &&OW,
115 std::unique_ptr<MCCodeEmitter> &&CE,
118 std::unique_ptr<MCAsmBackend> &&TAB,
119 std::unique_ptr<MCObjectWriter> &&OW,
120 std::unique_ptr<MCCodeEmitter> &&CE,
128 std::unique_ptr<MCRelocationInfo> &&RelInfo);
156 bool LargeCodeModel);
183 unsigned SyntaxVariant,
191 std::unique_ptr<MCAsmBackend> &&TAB,
192 std::unique_ptr<MCObjectWriter> &&OW,
193 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
196 std::unique_ptr<MCObjectWriter> &&OW,
197 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll,
198 bool DWARFMustBeAtTheEnd);
201 std::unique_ptr<MCObjectWriter> &&OW,
202 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll,
203 bool IncrementalLinkerCompatible);
206 std::unique_ptr<MCAsmBackend> &&TAB,
207 std::unique_ptr<MCObjectWriter> &&OW,
208 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
211 std::unique_ptr<MCAsmBackend> &&TAB,
212 std::unique_ptr<MCObjectWriter> &&OW,
213 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
216 std::unique_ptr<MCAsmBackend> &&TAB,
217 std::unique_ptr<MCObjectWriter> &&OW,
218 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
222 std::unique_ptr<MCAsmBackend> &&TAB,
223 std::unique_ptr<MCObjectWriter> &&OW,
224 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
237 std::unique_ptr<MCRelocationInfo> &&RelInfo);
260 const char *ShortDesc;
264 const char *BackendName;
404 if (!MCAsmInfoCtorFn)
413 bool LargeCodeModel =
false)
const {
414 if (!MCObjectFileInfoCtorFn) {
419 return MCObjectFileInfoCtorFn(Ctx,
PIC, LargeCodeModel);
425 if (!MCInstrInfoCtorFn)
427 return MCInstrInfoCtorFn();
433 if (!MCInstrAnalysisCtorFn)
435 return MCInstrAnalysisCtorFn(
Info);
441 if (!MCRegInfoCtorFn)
443 return MCRegInfoCtorFn(
Triple(TT));
457 if (!MCSubtargetInfoCtorFn)
459 return MCSubtargetInfoCtorFn(
Triple(TheTriple), CPU, Features);
475 bool JIT =
false)
const {
476 if (!TargetMachineCtorFn)
478 return TargetMachineCtorFn(*
this,
Triple(TT), CPU, Features,
Options,
RM,
486 if (!MCAsmBackendCtorFn)
488 return MCAsmBackendCtorFn(*
this, STI,
MRI,
Options);
499 if (!MCAsmParserCtorFn)
501 return MCAsmParserCtorFn(STI, Parser, MII,
Options);
507 std::unique_ptr<MCStreamer> &&Streamer)
const {
508 if (!AsmPrinterCtorFn)
515 if (!MCDisassemblerCtorFn)
517 return MCDisassemblerCtorFn(*
this, STI, Ctx);
524 if (!MCInstPrinterCtorFn)
526 return MCInstPrinterCtorFn(
T, SyntaxVariant, MAI, MII,
MRI);
532 if (!MCCodeEmitterCtorFn)
534 return MCCodeEmitterCtorFn(II, Ctx);
546 std::unique_ptr<MCAsmBackend> &&TAB,
547 std::unique_ptr<MCObjectWriter> &&OW,
548 std::unique_ptr<MCCodeEmitter> &&Emitter,
550 bool IncrementalLinkerCompatible,
551 bool DWARFMustBeAtTheEnd)
const {
553 switch (
T.getObjectFormat()) {
557 assert(
T.isOSWindows() &&
"only Windows COFF is supported");
560 IncrementalLinkerCompatible);
563 if (MachOStreamerCtorFn)
566 DWARFMustBeAtTheEnd);
570 DWARFMustBeAtTheEnd);
573 if (ELFStreamerCtorFn)
581 if (WasmStreamerCtorFn)
591 if (XCOFFStreamerCtorFn)
599 if (SPIRVStreamerCtorFn)
607 if (DXContainerStreamerCtorFn)
615 if (ObjectTargetStreamerCtorFn)
616 ObjectTargetStreamerCtorFn(*
S, STI);
621 std::unique_ptr<formatted_raw_ostream> OS,
622 bool IsVerboseAsm,
bool UseDwarfDirectory,
624 std::unique_ptr<MCCodeEmitter> &&CE,
625 std::unique_ptr<MCAsmBackend> &&TAB,
626 bool ShowInst)
const {
629 Ctx,
std::move(OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,
638 bool IsVerboseAsm)
const {
639 if (AsmTargetStreamerCtorFn)
640 return AsmTargetStreamerCtorFn(
S, OS, InstPrint, IsVerboseAsm);
651 if (NullTargetStreamerCtorFn)
652 return NullTargetStreamerCtorFn(
S);
662 ? MCRelocationInfoCtorFn
664 return Fn(
Triple(TT), Ctx);
683 std::unique_ptr<MCRelocationInfo> &&RelInfo)
const {
686 return Fn(
Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
695 if (CustomBehaviourCtorFn)
696 return CustomBehaviourCtorFn(STI,
SrcMgr, MCII);
704 if (InstrPostProcessCtorFn)
705 return InstrPostProcessCtorFn(STI, MCII);
723 const Target *Current =
nullptr;
741 assert(Current &&
"Cannot increment end iterator!");
752 assert(Current &&
"Cannot dereference end iterator!");
813 const char *BackendName,
815 bool HasJIT =
false);
827 T.MCAsmInfoCtorFn = Fn;
840 T.MCObjectFileInfoCtorFn = Fn;
853 T.MCInstrInfoCtorFn = Fn;
860 T.MCInstrAnalysisCtorFn = Fn;
873 T.MCRegInfoCtorFn = Fn;
887 T.MCSubtargetInfoCtorFn = Fn;
900 T.TargetMachineCtorFn = Fn;
913 T.MCAsmBackendCtorFn = Fn;
926 T.MCAsmParserCtorFn = Fn;
939 T.AsmPrinterCtorFn = Fn;
953 T.MCDisassemblerCtorFn = Fn;
966 T.MCInstPrinterCtorFn = Fn;
979 T.MCCodeEmitterCtorFn = Fn;
983 T.COFFStreamerCtorFn = Fn;
987 T.MachOStreamerCtorFn = Fn;
991 T.ELFStreamerCtorFn = Fn;
995 T.SPIRVStreamerCtorFn = Fn;
999 T.DXContainerStreamerCtorFn = Fn;
1003 T.WasmStreamerCtorFn = Fn;
1007 T.XCOFFStreamerCtorFn = Fn;
1012 T.NullTargetStreamerCtorFn = Fn;
1017 T.AsmTargetStreamerCtorFn = Fn;
1023 T.ObjectTargetStreamerCtorFn = Fn;
1037 T.MCRelocationInfoCtorFn = Fn;
1050 T.MCSymbolizerCtorFn = Fn;
1064 T.CustomBehaviourCtorFn = Fn;
1078 T.InstrPostProcessCtorFn = Fn;
1099 bool HasJIT =
false>
1102 const char *BackendName) {
1108 return Arch == TargetArchType;
1128 return new MCAsmInfoImpl(TT,
Options);
1161 bool LargeCodeModel =
false) {
1162 return new MCObjectFileInfoImpl(Ctx,
PIC, LargeCodeModel);
1193 static MCInstrInfo *Allocator() {
return new MCInstrInfoImpl(); }
1225 return new MCInstrAnalysisImpl(
Info);
1258 return new MCRegisterInfoImpl();
1292 return new MCSubtargetInfoImpl();
1328 return new TargetMachineImpl(T, TT, CPU,
FS,
Options,
RM, CM, OL,
JIT);
1348 return new MCAsmBackendImpl(T, STI,
MRI);
1369 return new MCAsmParserImpl(STI,
P, MII,
Options);
1388 std::unique_ptr<MCStreamer> &&Streamer) {
1389 return new AsmPrinterImpl(
TM,
std::move(Streamer));
1409 return new MCCodeEmitterImpl();
1415 #endif // LLVM_MC_TARGETREGISTRY_H
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.
Generic assembler parser interface, for use by target specific assembly parsers.
AsmPrinter *(*)(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) AsmPrinterCtorTy
RegisterMCAsmInfo(Target &T)
This is an optimization pass for GlobalISel generic memory operations.
std::ptrdiff_t difference_type
RegisterMCCodeEmitter(Target &T)
MCAsmInfo *(*)(const MCRegisterInfo &MRI, const Triple &TT, const MCTargetOptions &Options) MCAsmInfoCtorFnTy
RegisterMCAsmBackend - Helper template for registering a target specific assembler backend.
RegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation.
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) WasmStreamerCtorTy
Context object for machine code objects.
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
MCStreamer * createDXContainerStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCInstrAnalysis *(*)(const MCInstrInfo *Info) MCInstrAnalysisCtorFnTy
MCRelocationInfo *(*)(const Triple &TT, MCContext &Ctx) MCRelocationInfoCtorTy
Abstracting the input code sequence (a sequence of MCInst) and assigning unique identifiers to every ...
MCTargetStreamer * createNullTargetStreamer(MCStreamer &S) const
MCObjectFileInfo * createMCObjectFileInfo(MCContext &Ctx, bool PIC, bool LargeCodeModel=false) const
Create a MCObjectFileInfo implementation for the specified target triple.
This class is intended to be used as a base class for asm properties and features specific to the tar...
Target - Wrapper for Target specific information.
Create MCExprs from relocations found in an object file.
MCAsmInfo * createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple, const MCTargetOptions &Options) const
createMCAsmInfo - Create a MCAsmInfo implementation for the specified target triple.
Helper template for registering a target object file info implementation.
MCSubtargetInfo *(*)(const Triple &TT, StringRef CPU, StringRef Features) MCSubtargetInfoCtorFnTy
MCSymbolizer *(*)(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) MCSymbolizerCtorTy
static void RegisterAsmTargetStreamer(Target &T, Target::AsmTargetStreamerCtorTy Fn)
static void RegisterWasmStreamer(Target &T, Target::WasmStreamerCtorTy Fn)
static void RegisterMCInstrAnalysis(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target.
Triple - Helper class for working with autoconf configuration names.
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll, bool IncrementalLinkerCompatible) COFFStreamerCtorTy
RegisterMCInstrAnalysis(Target &T)
mca::CustomBehaviour *(*)(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII) CustomBehaviourCtorTy
MCRelocationInfo * createMCRelocationInfo(StringRef TT, MCContext &Ctx) const
createMCRelocationInfo - Create a target specific MCRelocationInfo.
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)
RegisterMCInstrInfo(Target &T)
PassInstrumentationCallbacks PIC
RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn)
static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)
RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.
static void RegisterMCObjectFileInfo(Target &T, Target::MCObjectFileInfoCtorFnTy Fn)
Register a MCObjectFileInfo implementation for the given target.
TargetRegistry - Generic interface to target specific features.
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
MCTargetStreamer * createAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) const
alloca< 16 x float >, align 16 %tmp2=alloca< 16 x float >, align 16 store< 16 x float > %A,< 16 x float > *%tmp %s=bitcast< 16 x float > *%tmp to i8 *%s2=bitcast< 16 x float > *%tmp2 to i8 *call void @llvm.memcpy.i64(i8 *%s, i8 *%s2, i64 64, i32 16) %R=load< 16 x float > *%tmp2 ret< 16 x float > %R } declare void @llvm.memcpy.i64(i8 *nocapture, i8 *nocapture, i64, i32) nounwind which compiles to:_foo:subl $140, %esp movaps %xmm3, 112(%esp) movaps %xmm2, 96(%esp) movaps %xmm1, 80(%esp) movaps %xmm0, 64(%esp) movl 60(%esp), %eax movl %eax, 124(%esp) movl 56(%esp), %eax movl %eax, 120(%esp) movl 52(%esp), %eax< many many more 32-bit copies > movaps(%esp), %xmm0 movaps 16(%esp), %xmm1 movaps 32(%esp), %xmm2 movaps 48(%esp), %xmm3 addl $140, %esp ret On Nehalem, it may even be cheaper to just use movups when unaligned than to fall back to lower-granularity chunks. Implement processor-specific optimizations for parity with GCC on these processors. GCC does two optimizations:1. ix86_pad_returns inserts a noop before ret instructions if immediately preceded by a conditional branch or is the target of a jump. 2. ix86_avoid_jump_misspredicts inserts noops in cases where a 16-byte block of code contains more than 3 branches. The first one is done for all AMDs, Core2, and "Generic" The second one is done for:Atom, Pentium Pro, all AMDs, Pentium 4, Nocona, Core 2, and "Generic" Testcase:int x(int a) { return(a &0xf0)> >4 tmp
static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn)
RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.
static const Target * lookupTarget(const std::string &Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
RegisterMCInstrInfo - Helper template for registering a target instruction info implementation.
static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn)
MCTargetAsmParser *(*)(const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII, const MCTargetOptions &Options) MCAsmParserCtorTy
MCInstrInfo * createMCInstrInfo() const
createMCInstrInfo - Create a MCInstrInfo implementation.
MCInstrInfo *(*)() MCInstrInfoCtorFnTy
Symbolize and annotate disassembled instructions.
MCAsmBackend *(*)(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) MCAsmBackendCtorTy
MCRegisterInfo * createMCRegInfo(StringRef TT) const
createMCRegInfo - Create a MCRegisterInfo implementation.
MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, MCContext &Ctx) const
createMCCodeEmitter - Create a target specific code emitter.
RegisterMCObjectFileInfoFn(Target &T, Target::MCObjectFileInfoCtorFnTy Fn)
Streaming machine code generation interface.
bool hasTargetMachine() const
hasTargetMachine - Check if this target supports code generation.
RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn)
Generic interface to target specific assembler backends.
RegisterMCAsmParser - Helper template for registering a target specific assembly parser,...
const typedef char *(* LLVMSymbolLookupCallback)(void *DisInfo, uint64_t ReferenceValue, uint64_t *ReferenceType, uint64_t ReferencePC, const char **ReferenceName)
The type for the symbol lookup function.
static iterator_range< iterator > targets()
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,...
RegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation.
std::forward_iterator_tag iterator_category
bool operator==(const iterator &x) const
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
const Target * operator->() const
RegisterMCObjectFileInfo(Target &T)
bool operator!=(const iterator &x) const
static void RegisterInstrPostProcess(Target &T, Target::InstrPostProcessCtorTy Fn)
RegisterInstrPostProcess - Register an InstrPostProcess implementation for the given target.
static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn)
RegisterTargetMachine - Register a TargetMachine implementation for the given target.
RegisterTargetMachine - Helper template for registering a target machine implementation,...
MCTargetStreamer *(*)(MCStreamer &S, const MCSubtargetInfo &STI) ObjectTargetStreamerCtorTy
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
This class implements an extremely fast bulk output stream that can only output to a stream.
Target specific streamer interface.
Analysis containing CSE Info
RegisterMCSubtargetInfo(Target &T)
RegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementat...
RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation.
MCTargetAsmParser * createMCAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser, const MCInstrInfo &MII, const MCTargetOptions &Options) const
createMCAsmParser - Create a target specific assembly parser.
MCTargetStreamer *(*)(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) AsmTargetStreamerCtorTy
static void RegisterCustomBehaviour(Target &T, Target::CustomBehaviourCtorTy Fn)
RegisterCustomBehaviour - Register a CustomBehaviour implementation for the given target.
MCObjectFileInfo *(*)(MCContext &Ctx, bool PIC, bool LargeCodeModel) MCObjectFileInfoCtorFnTy
bool hasJIT() const
hasJIT - Check if this targets supports the just-in-time compilation.
mca::InstrPostProcess *(*)(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) InstrPostProcessCtorTy
MCStreamer * createWasmStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
static void RegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn)
RegisterMCAsmParser - Register a MCTargetAsmParser implementation for the given target.
static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn)
RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.
MCStreamer * createXCOFFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
RegisterMCAsmParser(Target &T)
static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn)
RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Class which can be overriden by targets to enforce instruction dependencies and behaviours that aren'...
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Superclass for all disassemblers.
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.
const Target * getNext() const
static void RegisterSPIRVStreamer(Target &T, Target::SPIRVStreamerCtorTy Fn)
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 void RegisterObjectTargetStreamer(Target &T, Target::ObjectTargetStreamerCtorTy Fn)
MCStreamer * createNullStreamer(MCContext &Ctx)
Create a dummy machine code streamer, which does nothing.
MCDisassembler * createMCDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx) const
RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementatio...
const char * getName() const
getName - Get the target name.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Primary interface to the complete machine description for the target machine.
static void RegisterDXContainerStreamer(Target &T, Target::DXContainerStreamerCtorTy Fn)
AsmPrinter * createAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) const
createAsmPrinter - Create a target specific assembly printer pass.
static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn)
RegisterMCAsmInfo - Register a MCAsmInfo implementation for the given target.
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll, bool DWARFMustBeAtTheEnd) MachOStreamerCtorTy
mca::CustomBehaviour * createCustomBehaviour(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII)
mca::InstrPostProcess * createInstrPostProcess(const MCSubtargetInfo &STI, const MCInstrInfo &MCII)
MCInstPrinter *(*)(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) MCInstPrinterCtorTy
static void RegisterMCSubtargetInfo(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for the given target.
void initMCObjectFileInfo(MCContext &MCCtx, bool PIC, bool LargeCodeModel=false)
MCStreamer * createNullStreamer(MCContext &Ctx) const
bool(*)(Triple::ArchType Arch) ArchMatchFnTy
MCRelocationInfo * createMCRelocationInfo(const Triple &TT, MCContext &Ctx)
RegisterMCRegInfo - Helper template for registering a target register info implementation.
MCAsmBackend * createMCAsmBackend(const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) const
createMCAsmBackend - Create a target specific assembly parser.
StringRef - Represent a constant reference to a string, i.e.
bool hasMCAsmParser() const
hasMCAsmParser - Check if this target supports assembly parsing.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
MCCodeEmitter *(*)(const MCInstrInfo &II, MCContext &Ctx) MCCodeEmitterCtorTy
MCDisassembler *(*)(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx) MCDisassemblerCtorTy
mca::CustomBehaviour * createCustomBehaviour(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII) const
createCustomBehaviour - Create a target specific CustomBehaviour.
bool hasMCAsmBackend() const
hasMCAsmBackend - Check if this target supports .o generation.
RegisterMCAsmInfo - Helper template for registering a target assembly info implementation.
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
MCStreamer * createSPIRVStreamer(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) const
createInstrPostProcess - Create a target specific InstrPostProcess.
RegisterMCRegInfo(Target &T)
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
static void printRegisteredTargetsForVersion(raw_ostream &OS)
printRegisteredTargetsForVersion - Print the registered targets appropriately for inclusion in a tool...
unsigned const MachineRegisterInfo * MRI
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) DXContainerStreamerCtorTy
Class which can be overriden by targets to modify the mca::Instruction objects before the pipeline st...
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCInstrAnalysis * createMCInstrAnalysis(const MCInstrInfo *Info) const
createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation.
MCSubtargetInfo * createMCSubtargetInfo(StringRef TheTriple, StringRef CPU, StringRef Features) const
createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn)
RegisterMCInstrInfo - Register a MCInstrInfo implementation for the given target.
static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn)
RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.
Interface to description of machine instruction set.
MCInstPrinter * createMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) const
MCCodeEmitter - Generic instruction encoding interface.
static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn)
RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.
Lightweight error class with error context and mandatory checking.
static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn)
RegisterMCAsmBackend(Target &T)
static bool getArchMatch(Triple::ArchType Arch)
RegisterTarget - Helper template for registering a target, for use in the target's initialization fun...
MCTargetAsmParser - Generic interface to target specific assembly parsers.
This class is intended to be used as a driving class for all asm writers.
static void RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn)
static void RegisterXCOFFStreamer(Target &T, Target::XCOFFStreamerCtorTy Fn)
MCRegisterInfo *(*)(const Triple &TT) MCRegInfoCtorFnTy
const char * getBackendName() const
getBackendName - Get the backend name.
const char * getShortDescription() const
getShortDescription - Get a short description of the target.
const Target & operator*() const
RegisterTarget(Target &T, const char *Name, const char *Desc, const char *BackendName)
static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn)
RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.
RegisterTargetMachine(Target &T)
A range adaptor for a pair of iterators.
RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn)
static void RegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn)
RegisterMCSymbolizer - Register an MCSymbolizer implementation for the given target.
const char LLVMTargetMachineRef TM
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) ELFStreamerCtorTy
RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...
MCTargetStreamer *(*)(MCStreamer &S) NullTargetStreamerCtorTy
Generic base class for all target subtargets.
RegisterMCRegInfoFn - Helper template for registering a target register info implementation.
RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter,...
MCSymbolizer * createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo)
static void RegisterMCRelocationInfo(Target &T, Target::MCRelocationInfoCtorTy Fn)
RegisterMCRelocationInfo - Register an MCRelocationInfo implementation for the given target.
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) SPIRVStreamerCtorTy
Helper template for registering a target object file info implementation.
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.
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.
RegisterAsmPrinter(Target &T)