diff --git a/llvm/include/llvm/Target/TargetRegistry.h b/llvm/include/llvm/Target/TargetRegistry.h index 37380ab047c4..a2ceed6a4de9 100644 --- a/llvm/include/llvm/Target/TargetRegistry.h +++ b/llvm/include/llvm/Target/TargetRegistry.h @@ -94,32 +94,31 @@ namespace llvm { bool HasJIT; AsmInfoCtorFnTy AsmInfoCtorFn; - + /// TargetMachineCtorFn - Construction function for this target's /// TargetMachine, if registered. TargetMachineCtorTy TargetMachineCtorFn; + /// AsmLexerCtorFn - Construction function for this target's TargetAsmLexer, + /// if registered. + AsmLexerCtorTy AsmLexerCtorFn; + + /// AsmParserCtorFn - Construction function for this target's + /// TargetAsmParser, if registered. + AsmParserCtorTy AsmParserCtorFn; + /// AsmPrinterCtorFn - Construction function for this target's AsmPrinter, /// if registered. AsmPrinterCtorTy AsmPrinterCtorFn; - /// AsmLexerCtorFn - Construction function for this target's TargetAsmLexer, - /// if registered. - AsmLexerCtorTy AsmLexerCtorFn; - - /// AsmParserCtorFn - Construction function for this target's - /// TargetAsmParser, if registered. - AsmParserCtorTy AsmParserCtorFn; - /// MCDisassemblerCtorFn - Construction function for this target's /// MCDisassembler, if registered. MCDisassemblerCtorTy MCDisassemblerCtorFn; - - /// MCInstPrinterCtorFn - Construction function for this target's + /// MCInstPrinterCtorFn - Construction function for this target's /// MCInstPrinter, if registered. MCInstPrinterCtorTy MCInstPrinterCtorFn; - + /// CodeEmitterCtorFn - Construction function for this target's CodeEmitter, /// if registered. CodeEmitterCtorTy CodeEmitterCtorFn; @@ -147,12 +146,15 @@ namespace llvm { /// hasTargetMachine - Check if this target supports code generation. bool hasTargetMachine() const { return TargetMachineCtorFn != 0; } - /// hasAsmPrinter - Check if this target supports .s printing. - bool hasAsmPrinter() const { return AsmPrinterCtorFn != 0; } + /// hasAsmLexer - Check if this target supports .s lexing. + bool hasAsmLexer() const { return AsmLexerCtorFn != 0; } /// hasAsmParser - Check if this target supports .s parsing. bool hasAsmParser() const { return AsmParserCtorFn != 0; } - + + /// hasAsmPrinter - Check if this target supports .s printing. + bool hasAsmPrinter() const { return AsmPrinterCtorFn != 0; } + /// hasMCDisassembler - Check if this target has a disassembler. bool hasMCDisassembler() const { return MCDisassemblerCtorFn != 0; } @@ -165,7 +167,7 @@ namespace llvm { /// @} /// @name Feature Constructors /// @{ - + /// createAsmInfo - Create a MCAsmInfo implementation for the specified /// target triple. /// @@ -178,7 +180,7 @@ namespace llvm { return 0; return AsmInfoCtorFn(*this, Triple); } - + /// createTargetMachine - Create a target specific machine implementation /// for the specified \arg Triple. /// @@ -193,6 +195,24 @@ namespace llvm { return TargetMachineCtorFn(*this, Triple, Features); } + /// createAsmLexer - Create a target specific assembly lexer. + /// + TargetAsmLexer *createAsmLexer(const MCAsmInfo &MAI) const { + if (!AsmLexerCtorFn) + return 0; + return AsmLexerCtorFn(*this, MAI); + } + + /// createAsmParser - Create a target specific assembly parser. + /// + /// \arg Parser - The target independent parser implementation to use for + /// parsing and lexing. + TargetAsmParser *createAsmParser(MCAsmParser &Parser) const { + if (!AsmParserCtorFn) + return 0; + return AsmParserCtorFn(*this, Parser); + } + /// createAsmPrinter - Create a target specific assembly printer pass. This /// takes ownership of the MCContext and MCStreamer objects but not the MAI. AsmPrinter *createAsmPrinter(formatted_raw_ostream &OS, TargetMachine &TM, @@ -203,24 +223,6 @@ namespace llvm { return AsmPrinterCtorFn(OS, TM, Ctx, Streamer, MAI); } - /// createAsmLexer - Create a target specific assembly lexer. - /// - TargetAsmLexer *createAsmLexer(const MCAsmInfo &MAI) const { - if (!AsmLexerCtorFn) - return 0; - return AsmLexerCtorFn(*this, MAI); - } - - /// createAsmParser - Create a target specific assembly parser. - /// - /// \arg Parser - The target independent parser implementation to use for - /// parsing and lexing. - TargetAsmParser *createAsmParser(MCAsmParser &Parser) const { - if (!AsmParserCtorFn) - return 0; - return AsmParserCtorFn(*this, Parser); - } - const MCDisassembler *createMCDisassembler() const { if (!MCDisassemblerCtorFn) return 0; @@ -234,8 +236,8 @@ namespace llvm { return 0; return MCInstPrinterCtorFn(*this, SyntaxVariant, MAI, O); } - - + + /// createCodeEmitter - Create a target specific code emitter. MCCodeEmitter *createCodeEmitter(TargetMachine &TM, MCContext &Ctx) const { if (!CodeEmitterCtorFn) @@ -270,8 +272,8 @@ namespace llvm { return *this; } iterator operator++(int) { // Postincrement - iterator tmp = *this; - ++*this; + iterator tmp = *this; + ++*this; return tmp; } @@ -313,7 +315,7 @@ namespace llvm { /// RegisterTarget - Register the given target. Attempts to register a /// target which has already been registered will be ignored. - /// + /// /// Clients are responsible for ensuring that registration doesn't occur /// while another thread is attempting to access the registry. Typically /// this is done by initializing all targets at program startup. @@ -321,7 +323,7 @@ namespace llvm { /// @param T - The target being registered. /// @param Name - The target name. This should be a static string. /// @param ShortDesc - A short target description. This should be a static - /// string. + /// string. /// @param TQualityFn - The triple match quality computation function for /// this target. /// @param HasJIT - Whether the target supports JIT code @@ -334,11 +336,11 @@ namespace llvm { /// RegisterAsmInfo - Register a MCAsmInfo implementation for the /// given target. - /// + /// /// Clients are responsible for ensuring that registration doesn't occur /// while another thread is attempting to access the registry. Typically /// this is done by initializing all targets at program startup. - /// + /// /// @param T - The target being registered. /// @param Fn - A function to construct a MCAsmInfo for the target. static void RegisterAsmInfo(Target &T, Target::AsmInfoCtorFnTy Fn) { @@ -346,26 +348,54 @@ namespace llvm { if (!T.AsmInfoCtorFn) T.AsmInfoCtorFn = Fn; } - + /// RegisterTargetMachine - Register a TargetMachine implementation for the /// given target. - /// + /// /// Clients are responsible for ensuring that registration doesn't occur /// while another thread is attempting to access the registry. Typically /// this is done by initializing all targets at program startup. - /// + /// /// @param T - The target being registered. /// @param Fn - A function to construct a TargetMachine for the target. - static void RegisterTargetMachine(Target &T, + static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn) { // Ignore duplicate registration. if (!T.TargetMachineCtorFn) T.TargetMachineCtorFn = Fn; } + /// RegisterAsmLexer - Register a TargetAsmLexer implementation for the + /// given target. + /// + /// Clients are responsible for ensuring that registration doesn't occur + /// while another thread is attempting to access the registry. Typically + /// this is done by initializing all targets at program startup. + /// + /// @param T - The target being registered. + /// @param Fn - A function to construct an AsmLexer for the target. + static void RegisterAsmLexer(Target &T, Target::AsmLexerCtorTy Fn) { + if (!T.AsmLexerCtorFn) + T.AsmLexerCtorFn = Fn; + } + + /// RegisterAsmParser - Register a TargetAsmParser implementation for the + /// given target. + /// + /// Clients are responsible for ensuring that registration doesn't occur + /// while another thread is attempting to access the registry. Typically + /// this is done by initializing all targets at program startup. + /// + /// @param T - The target being registered. + /// @param Fn - A function to construct an AsmParser for the target. + static void RegisterAsmParser(Target &T, Target::AsmParserCtorTy Fn) { + if (!T.AsmParserCtorFn) + T.AsmParserCtorFn = Fn; + } + /// RegisterAsmPrinter - Register an AsmPrinter implementation for the given /// target. - /// + /// /// Clients are responsible for ensuring that registration doesn't occur /// while another thread is attempting to access the registry. Typically /// this is done by initializing all targets at program startup. @@ -378,44 +408,16 @@ namespace llvm { T.AsmPrinterCtorFn = Fn; } - /// RegisterAsmLexer - Register a TargetAsmLexer implementation for the - /// given target. - /// - /// Clients are responsible for ensuring that registration doesn't occur - /// while another thread is attempting to access the registry. Typically - /// this is done by initializing all targets at program startup. - /// - /// @param T - The target being registered. - /// @param Fn - A function to construct an AsmPrinter for the target. - static void RegisterAsmLexer(Target &T, Target::AsmLexerCtorTy Fn) { - if (!T.AsmLexerCtorFn) - T.AsmLexerCtorFn = Fn; - } - - /// RegisterAsmParser - Register a TargetAsmParser implementation for the - /// given target. - /// - /// Clients are responsible for ensuring that registration doesn't occur - /// while another thread is attempting to access the registry. Typically - /// this is done by initializing all targets at program startup. - /// - /// @param T - The target being registered. - /// @param Fn - A function to construct an AsmPrinter for the target. - static void RegisterAsmParser(Target &T, Target::AsmParserCtorTy Fn) { - if (!T.AsmParserCtorFn) - T.AsmParserCtorFn = Fn; - } - /// RegisterMCDisassembler - Register a MCDisassembler implementation for /// the given target. - /// + /// /// Clients are responsible for ensuring that registration doesn't occur /// while another thread is attempting to access the registry. Typically /// this is done by initializing all targets at program startup. /// /// @param T - The target being registered. /// @param Fn - A function to construct an MCDisassembler for the target. - static void RegisterMCDisassembler(Target &T, + static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn) { if (!T.MCDisassemblerCtorFn) T.MCDisassemblerCtorFn = Fn; @@ -423,7 +425,7 @@ namespace llvm { /// RegisterMCInstPrinter - Register a MCInstPrinter implementation for the /// given target. - /// + /// /// Clients are responsible for ensuring that registration doesn't occur /// while another thread is attempting to access the registry. Typically /// this is done by initializing all targets at program startup. @@ -435,7 +437,7 @@ namespace llvm { if (!T.MCInstPrinterCtorFn) T.MCInstPrinterCtorFn = Fn; } - + /// RegisterCodeEmitter - Register a MCCodeEmitter implementation for the /// given target. /// @@ -444,7 +446,7 @@ namespace llvm { /// this is done by initializing all targets at program startup. /// /// @param T - The target being registered. - /// @param Fn - A function to construct an AsmPrinter for the target. + /// @param Fn - A function to construct an MCCodeEmitter for the target. static void RegisterCodeEmitter(Target &T, Target::CodeEmitterCtorTy Fn) { if (!T.CodeEmitterCtorFn) T.CodeEmitterCtorFn = Fn; @@ -498,7 +500,7 @@ namespace llvm { static const MCAsmInfo *Allocator(const Target &T, StringRef TT) { return new MCAsmInfoImpl(T, TT); } - + }; /// RegisterAsmInfoFn - Helper template for registering a target assembly info @@ -537,28 +539,6 @@ namespace llvm { } }; - /// RegisterAsmPrinter - Helper template for registering a target specific - /// assembly printer, for use in the target machine initialization - /// function. Usage: - /// - /// extern "C" void LLVMInitializeFooAsmPrinter() { - /// extern Target TheFooTarget; - /// RegisterAsmPrinter X(TheFooTarget); - /// } - template - struct RegisterAsmPrinter { - RegisterAsmPrinter(Target &T) { - TargetRegistry::RegisterAsmPrinter(T, &Allocator); - } - - private: - static AsmPrinter *Allocator(formatted_raw_ostream &OS, TargetMachine &TM, - MCContext &Ctx, MCStreamer &Streamer, - const MCAsmInfo *MAI) { - return new AsmPrinterImpl(OS, TM, Ctx, Streamer, MAI); - } - }; - /// RegisterAsmLexer - Helper template for registering a target specific /// assembly lexer, for use in the target machine initialization /// function. Usage: @@ -572,7 +552,7 @@ namespace llvm { RegisterAsmLexer(Target &T) { TargetRegistry::RegisterAsmLexer(T, &Allocator); } - + private: static TargetAsmLexer *Allocator(const Target &T, const MCAsmInfo &MAI) { return new AsmLexerImpl(T, MAI); @@ -599,6 +579,28 @@ namespace llvm { } }; + /// RegisterAsmPrinter - Helper template for registering a target specific + /// assembly printer, for use in the target machine initialization + /// function. Usage: + /// + /// extern "C" void LLVMInitializeFooAsmPrinter() { + /// extern Target TheFooTarget; + /// RegisterAsmPrinter X(TheFooTarget); + /// } + template + struct RegisterAsmPrinter { + RegisterAsmPrinter(Target &T) { + TargetRegistry::RegisterAsmPrinter(T, &Allocator); + } + + private: + static AsmPrinter *Allocator(formatted_raw_ostream &OS, TargetMachine &TM, + MCContext &Ctx, MCStreamer &Streamer, + const MCAsmInfo *MAI) { + return new AsmPrinterImpl(OS, TM, Ctx, Streamer, MAI); + } + }; + /// RegisterCodeEmitter - Helper template for registering a target specific /// machine code emitter, for use in the target initialization /// function. Usage: