19 #ifndef LLVM_SUPPORT_TARGETREGISTRY_H
20 #define LLVM_SUPPORT_TARGETREGISTRY_H
39 class MCInstrAnalysis;
44 class MCSubtargetInfo;
46 class MCRelocationInfo;
47 class MCTargetAsmParser;
48 class MCTargetOptions;
49 class MCTargetStreamer;
53 class raw_pwrite_stream;
54 class formatted_raw_ostream;
58 std::unique_ptr<formatted_raw_ostream> OS,
59 bool isVerboseAsm,
bool useDwarfDirectory,
60 MCInstPrinter *InstPrint, MCCodeEmitter *CE,
61 MCAsmBackend *TAB,
bool ShowInst);
65 raw_pwrite_stream &OS, MCCodeEmitter *CE,
68 raw_pwrite_stream &OS, MCCodeEmitter *CE,
69 bool RelaxAll,
bool DWARFMustBeAtTheEnd,
70 bool LabelSections =
false);
76 void *DisInfo, MCContext *Ctx,
77 std::unique_ptr<MCRelocationInfo> &&RelInfo);
124 unsigned SyntaxVariant,
140 bool DWARFMustBeAtTheEnd);
157 std::unique_ptr<MCRelocationInfo> &&RelInfo);
171 const char *ShortDesc;
253 : COFFStreamerCtorFn(nullptr), MachOStreamerCtorFn(nullptr),
254 ELFStreamerCtorFn(nullptr), NullTargetStreamerCtorFn(nullptr),
255 AsmTargetStreamerCtorFn(nullptr), ObjectTargetStreamerCtorFn(nullptr),
256 MCRelocationInfoCtorFn(nullptr), MCSymbolizerCtorFn(nullptr) {}
299 if (!MCAsmInfoCtorFn)
301 return MCAsmInfoCtorFn(MRI,
Triple(TheTriple));
306 if (MCAdjustCodeGenOptsFn)
307 MCAdjustCodeGenOptsFn(TT, RM, CM);
313 if (!MCInstrInfoCtorFn)
315 return MCInstrInfoCtorFn();
321 if (!MCInstrAnalysisCtorFn)
323 return MCInstrAnalysisCtorFn(Info);
329 if (!MCRegInfoCtorFn)
331 return MCRegInfoCtorFn(
Triple(TT));
345 if (!MCSubtargetInfoCtorFn)
347 return MCSubtargetInfoCtorFn(
Triple(TheTriple), CPU, Features);
362 if (!TargetMachineCtorFn)
364 return TargetMachineCtorFn(*
this,
Triple(TT), CPU, Features, Options, RM,
375 if (!MCAsmBackendCtorFn)
377 return MCAsmBackendCtorFn(*
this, MRI,
Triple(TheTriple), CPU, Options);
388 if (!MCAsmParserCtorFn)
390 return MCAsmParserCtorFn(STI, Parser, MII, Options);
396 std::unique_ptr<MCStreamer> &&Streamer)
const {
397 if (!AsmPrinterCtorFn)
399 return AsmPrinterCtorFn(TM, std::move(Streamer));
404 if (!MCDisassemblerCtorFn)
406 return MCDisassemblerCtorFn(*
this, STI, Ctx);
413 if (!MCInstPrinterCtorFn)
415 return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);
422 if (!MCCodeEmitterCtorFn)
424 return MCCodeEmitterCtorFn(II, MRI, Ctx);
440 bool DWARFMustBeAtTheEnd)
const {
447 S = COFFStreamerCtorFn(Ctx, TAB, OS, Emitter, RelaxAll,
448 IncrementalLinkerCompatible);
451 if (MachOStreamerCtorFn)
452 S = MachOStreamerCtorFn(Ctx, TAB, OS, Emitter, RelaxAll,
453 DWARFMustBeAtTheEnd);
456 DWARFMustBeAtTheEnd);
459 if (ELFStreamerCtorFn)
460 S = ELFStreamerCtorFn(T, Ctx, TAB, OS, Emitter, RelaxAll);
465 if (ObjectTargetStreamerCtorFn)
466 ObjectTargetStreamerCtorFn(*S, STI);
471 std::unique_ptr<formatted_raw_ostream> OS,
472 bool IsVerboseAsm,
bool UseDwarfDirectory,
477 UseDwarfDirectory, InstPrint, CE,
486 bool IsVerboseAsm)
const {
487 if (AsmTargetStreamerCtorFn)
488 return AsmTargetStreamerCtorFn(S, OS, InstPrint, IsVerboseAsm);
499 if (NullTargetStreamerCtorFn)
500 return NullTargetStreamerCtorFn(S);
510 ? MCRelocationInfoCtorFn
512 return Fn(
Triple(TT), Ctx);
531 std::unique_ptr<MCRelocationInfo> &&RelInfo)
const {
534 return Fn(
Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
550 :
public std::iterator<std::forward_iterator_tag, Target, ptrdiff_t> {
563 assert(Current &&
"Cannot increment end iterator!");
574 assert(Current &&
"Cannot dereference end iterator!");
632 bool HasJIT =
false);
644 T.MCAsmInfoCtorFn = Fn;
649 T.MCAdjustCodeGenOptsFn = Fn;
662 T.MCInstrInfoCtorFn = Fn;
669 T.MCInstrAnalysisCtorFn = Fn;
682 T.MCRegInfoCtorFn = Fn;
696 T.MCSubtargetInfoCtorFn = Fn;
709 T.TargetMachineCtorFn = Fn;
722 T.MCAsmBackendCtorFn = Fn;
735 T.MCAsmParserCtorFn = Fn;
748 T.AsmPrinterCtorFn = Fn;
762 T.MCDisassemblerCtorFn = Fn;
775 T.MCInstPrinterCtorFn = Fn;
788 T.MCCodeEmitterCtorFn = Fn;
792 T.COFFStreamerCtorFn = Fn;
796 T.MachOStreamerCtorFn = Fn;
800 T.ELFStreamerCtorFn = Fn;
805 T.NullTargetStreamerCtorFn = Fn;
810 T.AsmTargetStreamerCtorFn = Fn;
816 T.ObjectTargetStreamerCtorFn = Fn;
830 T.MCRelocationInfoCtorFn = Fn;
843 T.MCSymbolizerCtorFn = Fn;
871 return Arch == TargetArchType;
891 return new MCAsmInfoImpl(TT);
929 static MCInstrInfo *Allocator() {
return new MCInstrInfoImpl(); }
961 return new MCInstrAnalysisImpl(Info);
994 return new MCRegisterInfoImpl();
1028 return new MCSubtargetInfoImpl();
1065 return new TargetMachineImpl(T, TT, CPU, FS, Options, RM, CM, OL);
1085 return new MCAsmBackendImpl(T, MRI, TheTriple, CPU);
1106 return new MCAsmParserImpl(STI, P, MII, Options);
1125 std::unique_ptr<MCStreamer> &&Streamer) {
1126 return new AsmPrinterImpl(TM, std::move(Streamer));
1147 return new MCCodeEmitterImpl();
MCDisassembler * createMCDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx) const
RegisterMCRegInfoFn - Helper template for registering a target register info implementation.
RegisterTarget - Helper template for registering a target, for use in the target's initialization fun...
const Target * getNext() const
RegisterMCRegInfo(Target &T)
MCInstrInfo *(* MCInstrInfoCtorFnTy)(void)
const char * getName() const
getName - Get the target name.
RegisterTarget(Target &T, const char *Name, const char *Desc)
Generic assembler parser interface, for use by target specific assembly parsers.
MCTargetStreamer *(* ObjectTargetStreamerCtorTy)(MCStreamer &S, const MCSubtargetInfo &STI)
static void RegisterMCInstrAnalysis(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target...
MCTargetAsmParser - Generic interface to target specific assembly parsers.
Superclass for all disassemblers.
MCTargetAsmParser *(* MCAsmParserCtorTy)(const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII, const MCTargetOptions &Options)
const char *(* LLVMSymbolLookupCallback)(void *DisInfo, uint64_t ReferenceValue, uint64_t *ReferenceType, uint64_t ReferencePC, const char **ReferenceName)
The type for the symbol lookup function.
MCStreamer *(* ELFStreamerCtorTy)(const Triple &T, MCContext &Ctx, MCAsmBackend &TAB, raw_pwrite_stream &OS, MCCodeEmitter *Emitter, bool RelaxAll)
MachineInstrBuilder MachineInstrBuilder &DefMI const MCInstrDesc & Desc
RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn)
MCRegisterInfo * createMCRegInfo(StringRef TT) const
createMCRegInfo - Create a MCRegisterInfo implementation.
Target specific streamer interface.
MCStreamer * createNullStreamer(MCContext &Ctx)
Create a dummy machine code streamer, which does nothing.
RegisterMCInstrInfo - Helper template for registering a target instruction info implementation.
MCStreamer *(* COFFStreamerCtorTy)(MCContext &Ctx, MCAsmBackend &TAB, raw_pwrite_stream &OS, MCCodeEmitter *Emitter, bool RelaxAll, bool IncrementalLinkerCompatible)
MCStreamer * createMCObjectStreamer(const Triple &T, MCContext &Ctx, MCAsmBackend &TAB, raw_pwrite_stream &OS, MCCodeEmitter *Emitter, const MCSubtargetInfo &STI, bool RelaxAll, bool IncrementalLinkerCompatible, bool DWARFMustBeAtTheEnd) const
Create a target specific MCStreamer.
static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)
RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.
TargetRegistry - Generic interface to target specific features.
RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
static const Target * lookupTarget(const std::string &Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn)
RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.
MCSymbolizer * createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo)
bool hasTargetMachine() const
hasTargetMachine - Check if this target supports code generation.
static void RegisterAsmTargetStreamer(Target &T, Target::AsmTargetStreamerCtorTy Fn)
const Target & operator*() const
bool isOSWindows() const
Tests whether the OS is Windows.
RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementatio...
MCInstrInfo * createMCInstrInfo() const
createMCInstrInfo - Create a MCInstrInfo implementation.
MCSubtargetInfo * createMCSubtargetInfo(StringRef TheTriple, StringRef CPU, StringRef Features) const
createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
bool hasMCAsmBackend() const
hasMCAsmBackend - Check if this target supports .o generation.
RegisterMCAsmParser(Target &T)
MCAsmBackend * createMCAsmBackend(const MCRegisterInfo &MRI, StringRef TheTriple, StringRef CPU, const MCTargetOptions &Options) const
createMCAsmBackend - Create a target specific assembly parser.
RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter...
ObjectFormatType getObjectFormat() const
getFormat - Get the object format for this triple.
static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn)
AsmPrinter * createAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) const
createAsmPrinter - Create a target specific assembly printer pass.
RegisterMCCodeEmitter(Target &T)
void(* MCAdjustCodeGenOptsFnTy)(const Triple &TT, Reloc::Model RM, CodeModel::Model &CM)
Context object for machine code objects.
RegisterAsmPrinter(Target &T)
MCCodeEmitter *(* MCCodeEmitterCtorTy)(const MCInstrInfo &II, const MCRegisterInfo &MRI, MCContext &Ctx)
RegisterMCAdjustCodeGenOptsFn(Target &T, Target::MCAdjustCodeGenOptsFnTy Fn)
static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn)
RegisterTargetMachine - Register a TargetMachine implementation for the given target.
MCTargetStreamer * createAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) const
MCTargetAsmParser * createMCAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser, const MCInstrInfo &MII, const MCTargetOptions &Options) const
createMCAsmParser - Create a target specific assembly parser.
RegisterMCAsmBackend - Helper template for registering a target specific assembler backend...
static void RegisterTarget(Target &T, const char *Name, const char *ShortDesc, Target::ArchMatchFnTy ArchMatchFn, bool HasJIT=false)
RegisterTarget - Register the given target.
static iterator_range< iterator > targets()
MCRegisterInfo *(* MCRegInfoCtorFnTy)(const Triple &TT)
RegisterTargetMachine(Target &T)
AsmPrinter *(* AsmPrinterCtorTy)(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer)
MCInstrAnalysis * createMCInstrAnalysis(const MCInstrInfo *Info) const
createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
MCRelocationInfo * createMCRelocationInfo(const Triple &TT, MCContext &Ctx)
RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn)
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
This class is intended to be used as a base class for asm properties and features specific to the tar...
MCStreamer * createNullStreamer(MCContext &Ctx) const
bool hasJIT() const
hasJIT - Check if this targets supports the just-in-time compilation.
static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn)
RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.
MCAsmInfo * createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple) const
createMCAsmInfo - Create a MCAsmInfo implementation for the specified target triple.
Streaming machine code generation interface.
MCInstrAnalysis *(* MCInstrAnalysisCtorFnTy)(const MCInstrInfo *Info)
unsigned const MachineRegisterInfo * MRI
static void printRegisteredTargetsForVersion()
printRegisteredTargetsForVersion - Print the registered targets appropriately for inclusion in a tool...
RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn)
static void RegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn)
RegisterMCAsmParser - Register a MCTargetAsmParser implementation for the given target.
Symbolize and annotate disassembled instructions.
bool(* ArchMatchFnTy)(Triple::ArchType Arch)
MCDisassembler *(* MCDisassemblerCtorTy)(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx)
static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn)
MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint, MCCodeEmitter *CE, MCAsmBackend *TAB, bool ShowInst)
Create a machine code streamer which will print out assembly for the native target, suitable for compiling with a native assembler.
RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
const char * getShortDescription() const
getShortDescription - Get a short description of the target.
MCCodeEmitter - Generic instruction encoding interface.
Interface to description of machine instruction set.
This class is intended to be used as a driving class for all asm writers.
MCTargetStreamer *(* NullTargetStreamerCtorTy)(MCStreamer &S)
MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, const MCRegisterInfo &MRI, MCContext &Ctx) const
createMCCodeEmitter - Create a target specific code emitter.
Create MCExprs from relocations found in an object file.
static void registerMCAdjustCodeGenOpts(Target &T, Target::MCAdjustCodeGenOptsFnTy Fn)
MCRelocationInfo * createMCRelocationInfo(StringRef TT, MCContext &Ctx) const
createMCRelocationInfo - Create a target specific MCRelocationInfo.
RegisterMCSubtargetInfo(Target &T)
void adjustCodeGenOpts(const Triple &TT, Reloc::Model RM, CodeModel::Model &CM) const
static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn)
RegisterMCAsmInfo - Register a MCAsmInfo implementation for the given target.
bool hasMCAsmParser() const
hasMCAsmParser - Check if this target supports assembly parsing.
MCInstPrinter * createMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) const
static void RegisterMCSubtargetInfo(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for the given target...
MCSymbolizer *(* MCSymbolizerCtorTy)(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo)
static void RegisterObjectTargetStreamer(Target &T, Target::ObjectTargetStreamerCtorTy Fn)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
cl::opt< bool > IncrementalLinkerCompatible("incremental-linker-compatible", cl::desc("When used with filetype=obj, ""emit an object file which can be used with an incremental linker"))
TargetMachine *(* TargetMachineCtorTy)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, CodeModel::Model CM, CodeGenOpt::Level OL)
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, CodeModel::Model CM=CodeModel::Default, CodeGenOpt::Level OL=CodeGenOpt::Default) const
createTargetMachine - Create a target specific machine implementation for the specified Triple...
RegisterMCAsmInfo - Helper template for registering a target assembly info implementation.
RegisterMCInstrAnalysis(Target &T)
static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn)
RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.
MCAsmBackend *(* MCAsmBackendCtorTy)(const Target &T, const MCRegisterInfo &MRI, const Triple &TT, StringRef CPU, const MCTargetOptions &Options)
RegisterMCRegInfo - Helper template for registering a target register info implementation.
MCTargetStreamer * createNullTargetStreamer(MCStreamer &S) const
MCStreamer * createELFStreamer(MCContext &Ctx, MCAsmBackend &TAB, raw_pwrite_stream &OS, MCCodeEmitter *CE, bool RelaxAll)
Takes ownership of TAB and CE.
MCSymbolizer * createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) const
createMCSymbolizer - Create a target specific MCSymbolizer.
bool operator!=(const iterator &x) const
const Target * operator->() const
bool operator==(const iterator &x) const
A range adaptor for a pair of iterators.
static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn)
RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.
Target - Wrapper for Target specific information.
MCSubtargetInfo *(* MCSubtargetInfoCtorFnTy)(const Triple &TT, StringRef CPU, StringRef Features)
RegisterMCAsmBackend(Target &T)
MCAsmInfo *(* MCAsmInfoCtorFnTy)(const MCRegisterInfo &MRI, const Triple &TT)
RegisterMCAsmInfo(Target &T)
MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, bool IsVerboseAsm, bool UseDwarfDirectory, MCInstPrinter *InstPrint, MCCodeEmitter *CE, MCAsmBackend *TAB, bool ShowInst) const
RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation.
static bool getArchMatch(Triple::ArchType Arch)
RegisterMCAsmParser - Helper template for registering a target specific assembly parser, for use in the target machine initialization function.
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
MCRelocationInfo *(* MCRelocationInfoCtorTy)(const Triple &TT, MCContext &Ctx)
RegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation...
static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn)
RegisterMCInstrInfo - Register a MCInstrInfo implementation for the given target. ...
MCInstPrinter *(* MCInstPrinterCtorTy)(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI)
RegisterMCInstrInfo(Target &T)
MCSubtargetInfo - Generic base class for all target subtargets.
static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn)
static void RegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn)
RegisterMCSymbolizer - Register an MCSymbolizer implementation for the given target.
An abstract base class for streams implementations that also support a pwrite operation.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
cl::opt< bool > RelaxAll("mc-relax-all", cl::desc("When used with filetype=obj, ""relax all fixups in the emitted object file"))
RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function.
MCStreamer * createMachOStreamer(MCContext &Ctx, MCAsmBackend &TAB, raw_pwrite_stream &OS, MCCodeEmitter *CE, bool RelaxAll, bool DWARFMustBeAtTheEnd, bool LabelSections=false)
static void RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn)
Generic interface to target specific assembler backends.
RegisterAsmPrinter - Helper template for registering a target specific assembly printer, for use in the target machine initialization function.
Lightweight error class with error context and mandatory checking.
const FeatureBitset Features
MCStreamer *(* MachOStreamerCtorTy)(MCContext &Ctx, MCAsmBackend &TAB, raw_pwrite_stream &OS, MCCodeEmitter *Emitter, bool RelaxAll, bool DWARFMustBeAtTheEnd)
static void RegisterMCRelocationInfo(Target &T, Target::MCRelocationInfoCtorTy Fn)
RegisterMCRelocationInfo - Register an MCRelocationInfo implementation for the given target...
Primary interface to the complete machine description for the target machine.
static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn)
RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.
StringRef - Represent a constant reference to a string, i.e.
RegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementat...
MCTargetStreamer *(* AsmTargetStreamerCtorTy)(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm)
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.
RegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation...
RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation...