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,
123 std::unique_ptr<MCRelocationInfo> &&RelInfo);
151 bool LargeCodeModel);
178 unsigned SyntaxVariant,
186 std::unique_ptr<MCAsmBackend> &&TAB,
187 std::unique_ptr<MCObjectWriter> &&OW,
188 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
191 std::unique_ptr<MCObjectWriter> &&OW,
192 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll,
193 bool DWARFMustBeAtTheEnd);
196 std::unique_ptr<MCObjectWriter> &&OW,
197 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll,
198 bool IncrementalLinkerCompatible);
201 std::unique_ptr<MCAsmBackend> &&TAB,
202 std::unique_ptr<MCObjectWriter> &&OW,
203 std::unique_ptr<MCCodeEmitter> &&Emitter,
bool RelaxAll);
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);
226 std::unique_ptr<MCRelocationInfo> &&RelInfo);
249 const char *ShortDesc;
253 const char *BackendName;
392 if (!MCAsmInfoCtorFn)
401 bool LargeCodeModel =
false)
const {
402 if (!MCObjectFileInfoCtorFn) {
407 return MCObjectFileInfoCtorFn(Ctx,
PIC, LargeCodeModel);
413 if (!MCInstrInfoCtorFn)
415 return MCInstrInfoCtorFn();
421 if (!MCInstrAnalysisCtorFn)
423 return MCInstrAnalysisCtorFn(
Info);
429 if (!MCRegInfoCtorFn)
431 return MCRegInfoCtorFn(
Triple(TT));
445 if (!MCSubtargetInfoCtorFn)
447 return MCSubtargetInfoCtorFn(
Triple(TheTriple), CPU, Features);
463 bool JIT =
false)
const {
464 if (!TargetMachineCtorFn)
466 return TargetMachineCtorFn(*
this,
Triple(TT), CPU, Features,
Options,
RM,
474 if (!MCAsmBackendCtorFn)
476 return MCAsmBackendCtorFn(*
this, STI,
MRI,
Options);
487 if (!MCAsmParserCtorFn)
489 return MCAsmParserCtorFn(STI, Parser, MII,
Options);
495 std::unique_ptr<MCStreamer> &&Streamer)
const {
496 if (!AsmPrinterCtorFn)
503 if (!MCDisassemblerCtorFn)
505 return MCDisassemblerCtorFn(*
this, STI, Ctx);
512 if (!MCInstPrinterCtorFn)
514 return MCInstPrinterCtorFn(
T, SyntaxVariant, MAI, MII,
MRI);
520 if (!MCCodeEmitterCtorFn)
522 return MCCodeEmitterCtorFn(II, Ctx);
534 std::unique_ptr<MCAsmBackend> &&TAB,
535 std::unique_ptr<MCObjectWriter> &&OW,
536 std::unique_ptr<MCCodeEmitter> &&Emitter,
538 bool IncrementalLinkerCompatible,
539 bool DWARFMustBeAtTheEnd)
const {
541 switch (
T.getObjectFormat()) {
547 assert(
T.isOSWindows() &&
"only Windows COFF is supported");
550 IncrementalLinkerCompatible);
553 if (MachOStreamerCtorFn)
556 DWARFMustBeAtTheEnd);
560 DWARFMustBeAtTheEnd);
563 if (ELFStreamerCtorFn)
571 if (WasmStreamerCtorFn)
581 if (XCOFFStreamerCtorFn)
589 if (SPIRVStreamerCtorFn)
597 if (ObjectTargetStreamerCtorFn)
598 ObjectTargetStreamerCtorFn(*
S, STI);
603 std::unique_ptr<formatted_raw_ostream> OS,
604 bool IsVerboseAsm,
bool UseDwarfDirectory,
606 std::unique_ptr<MCCodeEmitter> &&CE,
607 std::unique_ptr<MCAsmBackend> &&TAB,
608 bool ShowInst)
const {
611 Ctx,
std::move(OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,
620 bool IsVerboseAsm)
const {
621 if (AsmTargetStreamerCtorFn)
622 return AsmTargetStreamerCtorFn(
S, OS, InstPrint, IsVerboseAsm);
633 if (NullTargetStreamerCtorFn)
634 return NullTargetStreamerCtorFn(
S);
644 ? MCRelocationInfoCtorFn
646 return Fn(
Triple(TT), Ctx);
665 std::unique_ptr<MCRelocationInfo> &&RelInfo)
const {
668 return Fn(
Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
677 if (CustomBehaviourCtorFn)
678 return CustomBehaviourCtorFn(STI,
SrcMgr, MCII);
686 if (InstrPostProcessCtorFn)
687 return InstrPostProcessCtorFn(STI, MCII);
705 const Target *Current =
nullptr;
723 assert(Current &&
"Cannot increment end iterator!");
734 assert(Current &&
"Cannot dereference end iterator!");
795 const char *BackendName,
797 bool HasJIT =
false);
809 T.MCAsmInfoCtorFn = Fn;
822 T.MCObjectFileInfoCtorFn = Fn;
835 T.MCInstrInfoCtorFn = Fn;
842 T.MCInstrAnalysisCtorFn = Fn;
855 T.MCRegInfoCtorFn = Fn;
869 T.MCSubtargetInfoCtorFn = Fn;
882 T.TargetMachineCtorFn = Fn;
895 T.MCAsmBackendCtorFn = Fn;
908 T.MCAsmParserCtorFn = Fn;
921 T.AsmPrinterCtorFn = Fn;
935 T.MCDisassemblerCtorFn = Fn;
948 T.MCInstPrinterCtorFn = Fn;
961 T.MCCodeEmitterCtorFn = Fn;
965 T.COFFStreamerCtorFn = Fn;
969 T.MachOStreamerCtorFn = Fn;
973 T.ELFStreamerCtorFn = Fn;
977 T.SPIRVStreamerCtorFn = Fn;
981 T.WasmStreamerCtorFn = Fn;
985 T.XCOFFStreamerCtorFn = Fn;
990 T.NullTargetStreamerCtorFn = Fn;
995 T.AsmTargetStreamerCtorFn = Fn;
1001 T.ObjectTargetStreamerCtorFn = Fn;
1015 T.MCRelocationInfoCtorFn = Fn;
1028 T.MCSymbolizerCtorFn = Fn;
1042 T.CustomBehaviourCtorFn = Fn;
1056 T.InstrPostProcessCtorFn = Fn;
1077 bool HasJIT =
false>
1080 const char *BackendName) {
1086 return Arch == TargetArchType;
1106 return new MCAsmInfoImpl(TT,
Options);
1139 bool LargeCodeModel =
false) {
1140 return new MCObjectFileInfoImpl(Ctx,
PIC, LargeCodeModel);
1171 static MCInstrInfo *Allocator() {
return new MCInstrInfoImpl(); }
1203 return new MCInstrAnalysisImpl(
Info);
1236 return new MCRegisterInfoImpl();
1270 return new MCSubtargetInfoImpl();
1306 return new TargetMachineImpl(T, TT, CPU,
FS,
Options,
RM, CM, OL,
JIT);
1326 return new MCAsmBackendImpl(T, STI,
MRI);
1347 return new MCAsmParserImpl(STI,
P, MII,
Options);
1366 std::unique_ptr<MCStreamer> &&Streamer) {
1367 return new AsmPrinterImpl(
TM,
std::move(Streamer));
1387 return new MCCodeEmitterImpl();
1393 #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)
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.
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
MCInstrAnalysis *(*)(const MCInstrInfo *Info) MCInstrAnalysisCtorFnTy
MCRelocationInfo *(*)(const Triple &TT, MCContext &Ctx) MCRelocationInfoCtorTy
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.
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
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.
RegisterAsmPrinter(Target &T)