diff options
Diffstat (limited to 'include/llvm/Target')
| -rw-r--r-- | include/llvm/Target/TargetMachine.h | 21 | ||||
| -rw-r--r-- | include/llvm/Target/TargetMachineRegistry.h | 47 | ||||
| -rw-r--r-- | include/llvm/Target/TargetRegistry.h | 16 | ||||
| -rw-r--r-- | include/llvm/Target/TargetSelect.h | 4 |
4 files changed, 50 insertions, 38 deletions
diff --git a/include/llvm/Target/TargetMachine.h b/include/llvm/Target/TargetMachine.h index 5ac1d69..ce293d5 100644 --- a/include/llvm/Target/TargetMachine.h +++ b/include/llvm/Target/TargetMachine.h @@ -19,7 +19,6 @@ namespace llvm { -class Target; class TargetAsmInfo; class TargetData; class TargetSubtarget; @@ -100,14 +99,11 @@ class TargetMachine { TargetMachine(const TargetMachine &); // DO NOT IMPLEMENT void operator=(const TargetMachine &); // DO NOT IMPLEMENT protected: // Can only create subclasses. - TargetMachine(const Target &); + TargetMachine(); /// getSubtargetImpl - virtual method implemented by subclasses that returns /// a reference to that target's TargetSubtarget-derived member variable. virtual const TargetSubtarget *getSubtargetImpl() const { return 0; } - - /// TheTarget - The Target that this machine was created for. - const Target &TheTarget; /// AsmInfo - Contains target specific asm information. /// @@ -120,7 +116,18 @@ protected: // Can only create subclasses. public: virtual ~TargetMachine(); - const Target &getTarget() const { return TheTarget; } + /// getModuleMatchQuality - This static method should be implemented by + /// targets to indicate how closely they match the specified module. This is + /// used by the LLC tool to determine which target to use when an explicit + /// -march option is not specified. If a target returns zero, it will never + /// be chosen without an explicit -march option. + static unsigned getModuleMatchQuality(const Module &) { return 0; } + + /// getJITMatchQuality - This static method should be implemented by targets + /// that provide JIT capabilities to indicate how suitable they are for + /// execution on the current host. If a value of 0 is returned, the target + /// will not be used unless an explicit -march option is used. + static unsigned getJITMatchQuality() { return 0; } // Interfaces to the major aspects of target machine information: // -- Instruction opcode and operand information @@ -301,7 +308,7 @@ public: /// class LLVMTargetMachine : public TargetMachine { protected: // Can only create subclasses. - LLVMTargetMachine(const Target &T) : TargetMachine(T) { } + LLVMTargetMachine() { } /// addCommonCodeGenPasses - Add standard LLVM codegen passes used for /// both emitting to assembly files or machine code output. diff --git a/include/llvm/Target/TargetMachineRegistry.h b/include/llvm/Target/TargetMachineRegistry.h index 6b78a58..b7ea448 100644 --- a/include/llvm/Target/TargetMachineRegistry.h +++ b/include/llvm/Target/TargetMachineRegistry.h @@ -19,21 +19,25 @@ #include "llvm/Module.h" #include "llvm/Support/Registry.h" -#include "llvm/Target/TargetRegistry.h" namespace llvm { class Module; - class Target; class TargetMachine; struct TargetMachineRegistryEntry { - const Target &TheTarget; const char *Name; const char *ShortDesc; + TargetMachine *(*CtorFn)(const Module &, const std::string &); + unsigned (*ModuleMatchQualityFn)(const Module &M); + unsigned (*JITMatchQualityFn)(); public: - TargetMachineRegistryEntry(const Target &T, const char *N, const char *SD) - : TheTarget(T), Name(N), ShortDesc(SD) {} + TargetMachineRegistryEntry(const char *N, const char *SD, + TargetMachine *(*CF)(const Module &, const std::string &), + unsigned (*MMF)(const Module &M), + unsigned (*JMF)()) + : Name(N), ShortDesc(SD), CtorFn(CF), ModuleMatchQualityFn(MMF), + JITMatchQualityFn(JMF) {} }; template<> @@ -46,15 +50,24 @@ namespace llvm { }; struct TargetMachineRegistry : public Registry<TargetMachine> { + /// getClosestStaticTargetForModule - Given an LLVM module, pick the best + /// target that is compatible with the module. If no close target can be + /// found, this returns null and sets the Error string to a reason. + static const entry *getClosestStaticTargetForModule(const Module &M, + std::string &Error); + + /// getClosestTargetForJIT - Pick the best target that is compatible with + /// the current host. If no close target can be found, this returns null + /// and sets the Error string to a reason. + static const entry *getClosestTargetForJIT(std::string &Error); }; //===--------------------------------------------------------------------===// /// RegisterTarget - This class is used to make targets automatically register - /// themselves with the tools they are linked with. Targets should define an - /// single global Target instance and register it using the TargetRegistry - /// interfaces. Targets must also include a static instance of this class. - /// + /// themselves with the tool they are linked. Targets should define an + /// instance of this and implement the static methods described in the + /// TargetMachine comments. /// The type 'TargetMachineImpl' should provide a constructor with two /// parameters: /// - const Module& M: the module that is being compiled: @@ -63,19 +76,19 @@ namespace llvm { template<class TargetMachineImpl> struct RegisterTarget { - RegisterTarget(Target &T, const char *Name, const char *ShortDesc) - : Entry(T, Name, ShortDesc), - Node(Entry) { - TargetRegistry::RegisterTargetMachine(T, &Allocator); - } + RegisterTarget(const char *Name, const char *ShortDesc) + : Entry(Name, ShortDesc, &Allocator, + &TargetMachineImpl::getModuleMatchQuality, + &TargetMachineImpl::getJITMatchQuality), + Node(Entry) + {} private: TargetMachineRegistry::entry Entry; TargetMachineRegistry::node Node; - static TargetMachine *Allocator(const Target &T, const Module &M, - const std::string &FS) { - return new TargetMachineImpl(T, M, FS); + static TargetMachine *Allocator(const Module &M, const std::string &FS) { + return new TargetMachineImpl(M, FS); } }; diff --git a/include/llvm/Target/TargetRegistry.h b/include/llvm/Target/TargetRegistry.h index 95cf35c..204d5b0 100644 --- a/include/llvm/Target/TargetRegistry.h +++ b/include/llvm/Target/TargetRegistry.h @@ -42,8 +42,7 @@ namespace llvm { typedef unsigned (*ModuleMatchQualityFnTy)(const Module &M); typedef unsigned (*JITMatchQualityFnTy)(); - typedef TargetMachine *(*TargetMachineCtorTy)(const Target &, - const Module &, + typedef TargetMachine *(*TargetMachineCtorTy)(const Module &, const std::string &); typedef FunctionPass *(*AsmPrinterCtorTy)(formatted_raw_ostream &, TargetMachine &, @@ -88,22 +87,18 @@ namespace llvm { /// getShortDescription - Get a short description of the target. const char *getShortDescription() const { return ShortDesc; } - /// getJITMatchQuality - Get the quality of this targets match for use as a - /// JIT. - unsigned getJITMatchQuality() const { return JITMatchQualityFn(); } - /// createTargetMachine - Create a target specific machine implementation. TargetMachine *createTargetMachine(const Module &M, - const std::string &Features) const { + const std::string &Features) { if (!TargetMachineCtorFn) return 0; - return TargetMachineCtorFn(*this, M, Features); + return TargetMachineCtorFn(M, Features); } /// createAsmPrinter - Create a target specific assembly printer pass. FunctionPass *createAsmPrinter(formatted_raw_ostream &OS, TargetMachine &M, - bool Verbose) const { + bool Verbose) { if (!AsmPrinterCtorFn) return 0; return AsmPrinterCtorFn(OS, M, Verbose); @@ -140,8 +135,7 @@ namespace llvm { /// @name Target Registration /// @{ - /// RegisterTarget - Register the given target. Attempts to register a - /// target which has already been registered will be ignored. + /// RegisterTarget - Register the given target. /// /// Clients are responsible for ensuring that registration doesn't occur /// while another thread is attempting to access the registry. Typically diff --git a/include/llvm/Target/TargetSelect.h b/include/llvm/Target/TargetSelect.h index a360f73..19b660b 100644 --- a/include/llvm/Target/TargetSelect.h +++ b/include/llvm/Target/TargetSelect.h @@ -58,9 +58,7 @@ namespace llvm { inline bool InitializeNativeTarget() { // If we have a native target, initialize it to ensure it is linked in. #ifdef LLVM_NATIVE_ARCH -#define DoInit2(TARG) \ - LLVMInitialize ## TARG ## Info (); \ - LLVMInitialize ## TARG () +#define DoInit2(TARG) LLVMInitialize ## TARG () #define DoInit(T) DoInit2(T) DoInit(LLVM_NATIVE_ARCH); return false; |