From 24b54250728986e87a21d2d65d46c3b87d7a6c5a Mon Sep 17 00:00:00 2001 From: Daniel Dunbar Date: Sun, 21 Feb 2010 21:53:37 +0000 Subject: [PATCH] Formatting tweaks (trailing whitespace, ordering, comments). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96761 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Target/TargetRegistry.h | 180 ++++++++++++++------------- 1 file changed, 91 insertions(+), 89 deletions(-) diff --git a/include/llvm/Target/TargetRegistry.h b/include/llvm/Target/TargetRegistry.h index 37380ab047c..a2ceed6a4de 100644 --- a/include/llvm/Target/TargetRegistry.h +++ b/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; - /// 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; - + + /// AsmPrinterCtorFn - Construction function for this target's AsmPrinter, + /// if registered. + AsmPrinterCtorTy AsmPrinterCtorFn; + /// 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,16 +195,6 @@ namespace llvm { return TargetMachineCtorFn(*this, Triple, Features); } - /// 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, - MCContext &Ctx, MCStreamer &Streamer, - const MCAsmInfo *MAI) const { - if (!AsmPrinterCtorFn) - return 0; - return AsmPrinterCtorFn(OS, TM, Ctx, Streamer, MAI); - } - /// createAsmLexer - Create a target specific assembly lexer. /// TargetAsmLexer *createAsmLexer(const MCAsmInfo &MAI) const { @@ -210,7 +202,7 @@ namespace llvm { return 0; return AsmLexerCtorFn(*this, MAI); } - + /// createAsmParser - Create a target specific assembly parser. /// /// \arg Parser - The target independent parser implementation to use for @@ -220,7 +212,17 @@ namespace llvm { 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, + MCContext &Ctx, MCStreamer &Streamer, + const MCAsmInfo *MAI) const { + if (!AsmPrinterCtorFn) + return 0; + return AsmPrinterCtorFn(OS, TM, Ctx, Streamer, MAI); + } + 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,76 +348,76 @@ 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; } - /// 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. - /// - /// @param T - The target being registered. - /// @param Fn - A function to construct an AsmPrinter for the target. - static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn) { - // Ignore duplicate registration. - if (!T.AsmPrinterCtorFn) - 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. + /// @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 AsmPrinter for the target. + /// @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. + /// + /// @param T - The target being registered. + /// @param Fn - A function to construct an AsmPrinter for the target. + static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn) { + // Ignore duplicate registration. + if (!T.AsmPrinterCtorFn) + T.AsmPrinterCtorFn = 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: -- 2.34.1