From 51b198af83cb0080c2709b04c129a3d774c07765 Mon Sep 17 00:00:00 2001 From: Daniel Dunbar Date: Wed, 15 Jul 2009 20:24:03 +0000 Subject: [PATCH] Reapply TargetRegistry refactoring commits. --- Reverse-merging r75799 into '.': U test/Analysis/PointerTracking U include/llvm/Target/TargetMachineRegistry.h U include/llvm/Target/TargetMachine.h U include/llvm/Target/TargetRegistry.h U include/llvm/Target/TargetSelect.h U tools/lto/LTOCodeGenerator.cpp U tools/lto/LTOModule.cpp U tools/llc/llc.cpp U lib/Target/PowerPC/PPCTargetMachine.h U lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp U lib/Target/PowerPC/PPCTargetMachine.cpp U lib/Target/PowerPC/PPC.h U lib/Target/ARM/ARMTargetMachine.cpp U lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp U lib/Target/ARM/ARMTargetMachine.h U lib/Target/ARM/ARM.h U lib/Target/XCore/XCoreTargetMachine.cpp U lib/Target/XCore/XCoreTargetMachine.h U lib/Target/PIC16/PIC16TargetMachine.cpp U lib/Target/PIC16/PIC16TargetMachine.h U lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp U lib/Target/Alpha/AlphaTargetMachine.cpp U lib/Target/Alpha/AlphaTargetMachine.h U lib/Target/X86/X86TargetMachine.h U lib/Target/X86/X86.h U lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h U lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp U lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h U lib/Target/X86/X86TargetMachine.cpp U lib/Target/MSP430/MSP430TargetMachine.cpp U lib/Target/MSP430/MSP430TargetMachine.h U lib/Target/CppBackend/CPPTargetMachine.h U lib/Target/CppBackend/CPPBackend.cpp U lib/Target/CBackend/CTargetMachine.h U lib/Target/CBackend/CBackend.cpp U lib/Target/TargetMachine.cpp U lib/Target/IA64/IA64TargetMachine.cpp U lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp U lib/Target/IA64/IA64TargetMachine.h U lib/Target/IA64/IA64.h U lib/Target/MSIL/MSILWriter.cpp U lib/Target/CellSPU/SPUTargetMachine.h U lib/Target/CellSPU/SPU.h U lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp U lib/Target/CellSPU/SPUTargetMachine.cpp U lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp U lib/Target/Mips/MipsTargetMachine.cpp U lib/Target/Mips/MipsTargetMachine.h U lib/Target/Mips/Mips.h U lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp U lib/Target/Sparc/SparcTargetMachine.cpp U lib/Target/Sparc/SparcTargetMachine.h U lib/ExecutionEngine/JIT/TargetSelect.cpp U lib/Support/TargetRegistry.cpp git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@75820 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Target/TargetMachine.h | 21 ++---- include/llvm/Target/TargetMachineRegistry.h | 47 +++++--------- include/llvm/Target/TargetRegistry.h | 16 +++-- include/llvm/Target/TargetSelect.h | 4 +- lib/ExecutionEngine/JIT/TargetSelect.cpp | 22 ++++--- lib/Support/TargetRegistry.cpp | 12 ++-- lib/Target/ARM/ARM.h | 2 +- lib/Target/ARM/ARMTargetMachine.cpp | 78 +++++----------------- lib/Target/ARM/ARMTargetMachine.h | 12 ++-- lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp | 9 ++- lib/Target/Alpha/AlphaTargetMachine.cpp | 37 ++--------- lib/Target/Alpha/AlphaTargetMachine.h | 5 +- lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp | 11 +++- lib/Target/CBackend/CBackend.cpp | 22 ++++--- lib/Target/CBackend/CTargetMachine.h | 8 +-- lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp | 14 ++-- lib/Target/CellSPU/SPU.h | 2 +- lib/Target/CellSPU/SPUTargetMachine.cpp | 23 ++----- lib/Target/CellSPU/SPUTargetMachine.h | 10 +-- lib/Target/CppBackend/CPPBackend.cpp | 3 +- lib/Target/CppBackend/CPPTargetMachine.h | 7 +- lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp | 8 ++- lib/Target/IA64/IA64.h | 2 +- lib/Target/IA64/IA64TargetMachine.cpp | 35 ++-------- lib/Target/IA64/IA64TargetMachine.h | 6 +- lib/Target/MSIL/MSILWriter.cpp | 7 +- lib/Target/MSP430/MSP430TargetMachine.cpp | 18 ++---- lib/Target/MSP430/MSP430TargetMachine.h | 3 +- lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp | 14 +++- lib/Target/Mips/Mips.h | 2 +- lib/Target/Mips/MipsTargetMachine.cpp | 51 ++++----------- lib/Target/Mips/MipsTargetMachine.h | 9 ++- lib/Target/PIC16/PIC16TargetMachine.cpp | 19 ++++-- lib/Target/PIC16/PIC16TargetMachine.h | 4 +- lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp | 15 +++-- lib/Target/PowerPC/PPC.h | 2 +- lib/Target/PowerPC/PPCTargetMachine.cpp | 75 +++++---------------- lib/Target/PowerPC/PPCTargetMachine.h | 15 ++--- lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp | 7 +- lib/Target/Sparc/SparcTargetMachine.cpp | 35 ++-------- lib/Target/Sparc/SparcTargetMachine.h | 3 +- lib/Target/TargetMachine.cpp | 4 +- lib/Target/TargetMachineRegistry.cpp | 78 ---------------------- lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h | 2 +- lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp | 11 +++- lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h | 2 +- lib/Target/X86/X86.h | 2 +- lib/Target/X86/X86TargetMachine.cpp | 86 ++++++------------------- lib/Target/X86/X86TargetMachine.h | 12 ++-- lib/Target/XCore/XCoreTargetMachine.cpp | 18 ++---- lib/Target/XCore/XCoreTargetMachine.h | 3 +- tools/llc/llc.cpp | 23 ++++--- tools/lto/LTOCodeGenerator.cpp | 8 +-- tools/lto/LTOModule.cpp | 6 +- 54 files changed, 312 insertions(+), 638 deletions(-) delete mode 100644 lib/Target/TargetMachineRegistry.cpp diff --git a/include/llvm/Target/TargetMachine.h b/include/llvm/Target/TargetMachine.h index ce293d5114d..5ac1d69941d 100644 --- a/include/llvm/Target/TargetMachine.h +++ b/include/llvm/Target/TargetMachine.h @@ -19,6 +19,7 @@ namespace llvm { +class Target; class TargetAsmInfo; class TargetData; class TargetSubtarget; @@ -99,11 +100,14 @@ class TargetMachine { TargetMachine(const TargetMachine &); // DO NOT IMPLEMENT void operator=(const TargetMachine &); // DO NOT IMPLEMENT protected: // Can only create subclasses. - TargetMachine(); + TargetMachine(const Target &); /// 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. /// @@ -116,18 +120,7 @@ protected: // Can only create subclasses. public: virtual ~TargetMachine(); - /// 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; } + const Target &getTarget() const { return TheTarget; } // Interfaces to the major aspects of target machine information: // -- Instruction opcode and operand information @@ -308,7 +301,7 @@ public: /// class LLVMTargetMachine : public TargetMachine { protected: // Can only create subclasses. - LLVMTargetMachine() { } + LLVMTargetMachine(const Target &T) : TargetMachine(T) { } /// 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 b7ea448b203..6b78a58ab0e 100644 --- a/include/llvm/Target/TargetMachineRegistry.h +++ b/include/llvm/Target/TargetMachineRegistry.h @@ -19,25 +19,21 @@ #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 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) {} + TargetMachineRegistryEntry(const Target &T, const char *N, const char *SD) + : TheTarget(T), Name(N), ShortDesc(SD) {} }; template<> @@ -50,24 +46,15 @@ namespace llvm { }; struct TargetMachineRegistry : public Registry { - /// 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 tool they are linked. Targets should define an - /// instance of this and implement the static methods described in the - /// TargetMachine comments. + /// 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. + /// /// The type 'TargetMachineImpl' should provide a constructor with two /// parameters: /// - const Module& M: the module that is being compiled: @@ -76,19 +63,19 @@ namespace llvm { template struct RegisterTarget { - RegisterTarget(const char *Name, const char *ShortDesc) - : Entry(Name, ShortDesc, &Allocator, - &TargetMachineImpl::getModuleMatchQuality, - &TargetMachineImpl::getJITMatchQuality), - Node(Entry) - {} + RegisterTarget(Target &T, const char *Name, const char *ShortDesc) + : Entry(T, Name, ShortDesc), + Node(Entry) { + TargetRegistry::RegisterTargetMachine(T, &Allocator); + } private: TargetMachineRegistry::entry Entry; TargetMachineRegistry::node Node; - static TargetMachine *Allocator(const Module &M, const std::string &FS) { - return new TargetMachineImpl(M, FS); + static TargetMachine *Allocator(const Target &T, const Module &M, + const std::string &FS) { + return new TargetMachineImpl(T, M, FS); } }; diff --git a/include/llvm/Target/TargetRegistry.h b/include/llvm/Target/TargetRegistry.h index 204d5b0c8f5..95cf35c4558 100644 --- a/include/llvm/Target/TargetRegistry.h +++ b/include/llvm/Target/TargetRegistry.h @@ -42,7 +42,8 @@ namespace llvm { typedef unsigned (*ModuleMatchQualityFnTy)(const Module &M); typedef unsigned (*JITMatchQualityFnTy)(); - typedef TargetMachine *(*TargetMachineCtorTy)(const Module &, + typedef TargetMachine *(*TargetMachineCtorTy)(const Target &, + const Module &, const std::string &); typedef FunctionPass *(*AsmPrinterCtorTy)(formatted_raw_ostream &, TargetMachine &, @@ -87,18 +88,22 @@ 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 std::string &Features) const { if (!TargetMachineCtorFn) return 0; - return TargetMachineCtorFn(M, Features); + return TargetMachineCtorFn(*this, M, Features); } /// createAsmPrinter - Create a target specific assembly printer pass. FunctionPass *createAsmPrinter(formatted_raw_ostream &OS, TargetMachine &M, - bool Verbose) { + bool Verbose) const { if (!AsmPrinterCtorFn) return 0; return AsmPrinterCtorFn(OS, M, Verbose); @@ -135,7 +140,8 @@ namespace llvm { /// @name Target Registration /// @{ - /// RegisterTarget - Register the given target. + /// 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 diff --git a/include/llvm/Target/TargetSelect.h b/include/llvm/Target/TargetSelect.h index 19b660b52da..a360f731ba8 100644 --- a/include/llvm/Target/TargetSelect.h +++ b/include/llvm/Target/TargetSelect.h @@ -58,7 +58,9 @@ 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 () +#define DoInit2(TARG) \ + LLVMInitialize ## TARG ## Info (); \ + LLVMInitialize ## TARG () #define DoInit(T) DoInit2(T) DoInit(LLVM_NATIVE_ARCH); return false; diff --git a/lib/ExecutionEngine/JIT/TargetSelect.cpp b/lib/ExecutionEngine/JIT/TargetSelect.cpp index 24dd0136398..93ad81f85f3 100644 --- a/lib/ExecutionEngine/JIT/TargetSelect.cpp +++ b/lib/ExecutionEngine/JIT/TargetSelect.cpp @@ -45,19 +45,22 @@ ExecutionEngine *JIT::createJIT(ModuleProvider *MP, std::string *ErrorStr, JITMemoryManager *JMM, CodeGenOpt::Level OptLevel, bool AllocateGVsWithCode) { - const TargetMachineRegistry::entry *TheArch = MArch; - if (TheArch == 0) { + const Target *TheTarget; + if (MArch == 0) { std::string Error; - TheArch = TargetMachineRegistry::getClosestTargetForJIT(Error); - if (TheArch == 0) { + TheTarget = TargetRegistry::getClosestTargetForJIT(Error); + if (TheTarget == 0) { if (ErrorStr) *ErrorStr = Error; return 0; } - } else if (TheArch->JITMatchQualityFn() == 0) { - cerr << "WARNING: This target JIT is not designed for the host you are" - << " running. If bad things happen, please choose a different " - << "-march switch.\n"; + } else { + TheTarget = &MArch->TheTarget; + if (TheTarget->getJITMatchQuality() == 0) { + cerr << "WARNING: This target JIT is not designed for the host you are" + << " running. If bad things happen, please choose a different " + << "-march switch.\n"; + } } // Package up features to be passed to target/subtarget @@ -71,7 +74,8 @@ ExecutionEngine *JIT::createJIT(ModuleProvider *MP, std::string *ErrorStr, } // Allocate a target... - TargetMachine *Target = TheArch->CtorFn(*MP->getModule(), FeaturesStr); + TargetMachine *Target = + TheTarget->createTargetMachine(*MP->getModule(), FeaturesStr); assert(Target && "Could not allocate target machine!"); // If the target supports JIT code generation, return a new JIT now. diff --git a/lib/Support/TargetRegistry.cpp b/lib/Support/TargetRegistry.cpp index 258d703d16d..77cf2dd72cf 100644 --- a/lib/Support/TargetRegistry.cpp +++ b/lib/Support/TargetRegistry.cpp @@ -111,15 +111,13 @@ void TargetRegistry::RegisterTarget(Target &T, Target::TripleMatchQualityFnTy TQualityFn, Target::ModuleMatchQualityFnTy MQualityFn, Target::JITMatchQualityFnTy JITQualityFn) { - // Note that we don't require the constructor functions already be defined, in - // case a module happens to initialize the optional functionality before the - // target. - assert(!T.Next && !T.Name && !T.ShortDesc && !T.TripleMatchQualityFn && - !T.ModuleMatchQualityFn && !T.JITMatchQualityFn && - "This Target already registered!"); - assert(Name && ShortDesc && TQualityFn && MQualityFn && JITQualityFn && "Missing required target information!"); + + // Check if this target has already been initialized, we allow this as a + // convenience to some clients. + if (T.Name) + return; // Add to the list of targets. T.Next = FirstTarget; diff --git a/lib/Target/ARM/ARM.h b/lib/Target/ARM/ARM.h index f6ae6806fda..1b5b828395a 100644 --- a/lib/Target/ARM/ARM.h +++ b/lib/Target/ARM/ARM.h @@ -94,7 +94,7 @@ inline static const char *ARMCondCodeToString(ARMCC::CondCodes CC) { FunctionPass *createARMISelDag(ARMBaseTargetMachine &TM); FunctionPass *createARMCodePrinterPass(formatted_raw_ostream &O, - ARMBaseTargetMachine &TM, + TargetMachine &TM, bool Verbose); FunctionPass *createARMCodeEmitterPass(ARMBaseTargetMachine &TM, MachineCodeEmitter &MCE); diff --git a/lib/Target/ARM/ARMTargetMachine.cpp b/lib/Target/ARM/ARMTargetMachine.cpp index 932659d8b66..ad800207382 100644 --- a/lib/Target/ARM/ARMTargetMachine.cpp +++ b/lib/Target/ARM/ARMTargetMachine.cpp @@ -36,8 +36,11 @@ extern "C" int ARMTargetMachineModule; int ARMTargetMachineModule = 0; // Register the target. -static RegisterTarget X("arm", "ARM"); -static RegisterTarget Y("thumb", "Thumb"); +extern Target TheARMTarget; +static RegisterTarget X(TheARMTarget, "arm", "ARM"); + +extern Target TheThumbTarget; +static RegisterTarget Y(TheThumbTarget, "thumb", "Thumb"); // Force static initialization. extern "C" void LLVMInitializeARMTarget() { } @@ -45,57 +48,32 @@ extern "C" void LLVMInitializeARMTarget() { } // No assembler printer by default ARMBaseTargetMachine::AsmPrinterCtorFn ARMBaseTargetMachine::AsmPrinterCtor = 0; -/// ThumbTargetMachine - Create an Thumb architecture model. -/// -unsigned ThumbTargetMachine::getJITMatchQuality() { -#if defined(__thumb__) - return 10; -#endif - return 0; -} - -unsigned ThumbTargetMachine::getModuleMatchQuality(const Module &M) { - std::string TT = M.getTargetTriple(); - // Match thumb-foo-bar, as well as things like thumbv5blah-* - if (TT.size() >= 6 && - (TT.substr(0, 6) == "thumb-" || TT.substr(0, 6) == "thumbv")) - return 20; - - // If the target triple is something non-thumb, we don't match. - if (!TT.empty()) return 0; - - if (M.getEndianness() == Module::LittleEndian && - M.getPointerSize() == Module::Pointer32) - return 10; // Weak match - else if (M.getEndianness() != Module::AnyEndianness || - M.getPointerSize() != Module::AnyPointerSize) - return 0; // Match for some other target - - return getJITMatchQuality()/2; -} - /// TargetMachine ctor - Create an ARM architecture model. /// -ARMBaseTargetMachine::ARMBaseTargetMachine(const Module &M, +ARMBaseTargetMachine::ARMBaseTargetMachine(const Target &T, + const Module &M, const std::string &FS, bool isThumb) - : Subtarget(M, FS, isThumb), + : LLVMTargetMachine(T), + Subtarget(M, FS, isThumb), FrameInfo(Subtarget), JITInfo(), InstrItins(Subtarget.getInstrItineraryData()) { DefRelocModel = getRelocationModel(); } -ARMTargetMachine::ARMTargetMachine(const Module &M, const std::string &FS) - : ARMBaseTargetMachine(M, FS, false), InstrInfo(Subtarget), +ARMTargetMachine::ARMTargetMachine(const Target &T, const Module &M, + const std::string &FS) + : ARMBaseTargetMachine(T, M, FS, false), InstrInfo(Subtarget), DataLayout(Subtarget.isAPCS_ABI() ? std::string("e-p:32:32-f64:32:32-i64:32:32") : std::string("e-p:32:32-f64:64:64-i64:64:64")), TLInfo(*this) { } -ThumbTargetMachine::ThumbTargetMachine(const Module &M, const std::string &FS) - : ARMBaseTargetMachine(M, FS, true), +ThumbTargetMachine::ThumbTargetMachine(const Target &T, const Module &M, + const std::string &FS) + : ARMBaseTargetMachine(T, M, FS, true), DataLayout(Subtarget.isAPCS_ABI() ? std::string("e-p:32:32-f64:32:32-i64:32:32-" "i16:16:32-i8:8:32-i1:8:32-a:0:32") : @@ -109,32 +87,6 @@ ThumbTargetMachine::ThumbTargetMachine(const Module &M, const std::string &FS) InstrInfo = new Thumb1InstrInfo(Subtarget); } -unsigned ARMTargetMachine::getJITMatchQuality() { -#if defined(__arm__) - return 10; -#endif - return 0; -} - -unsigned ARMTargetMachine::getModuleMatchQuality(const Module &M) { - std::string TT = M.getTargetTriple(); - // Match arm-foo-bar, as well as things like armv5blah-* - if (TT.size() >= 4 && - (TT.substr(0, 4) == "arm-" || TT.substr(0, 4) == "armv")) - return 20; - // If the target triple is something non-arm, we don't match. - if (!TT.empty()) return 0; - - if (M.getEndianness() == Module::LittleEndian && - M.getPointerSize() == Module::Pointer32) - return 10; // Weak match - else if (M.getEndianness() != Module::AnyEndianness || - M.getPointerSize() != Module::AnyPointerSize) - return 0; // Match for some other target - - return getJITMatchQuality()/2; -} - const TargetAsmInfo *ARMBaseTargetMachine::createTargetAsmInfo() const { switch (Subtarget.TargetType) { diff --git a/lib/Target/ARM/ARMTargetMachine.h b/lib/Target/ARM/ARMTargetMachine.h index 56b18ae36af..3fe259ad08d 100644 --- a/lib/Target/ARM/ARMTargetMachine.h +++ b/lib/Target/ARM/ARMTargetMachine.h @@ -42,12 +42,13 @@ protected: // To avoid having target depend on the asmprinter stuff libraries, asmprinter // set this functions to ctor pointer at startup time if they are linked in. typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o, - ARMBaseTargetMachine &tm, + TargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - ARMBaseTargetMachine(const Module &M, const std::string &FS, bool isThumb); + ARMBaseTargetMachine(const Target &T, const Module &M, const std::string &FS, + bool isThumb); virtual const ARMFrameInfo *getFrameInfo() const { return &FrameInfo; } virtual ARMJITInfo *getJITInfo() { return &JITInfo; } @@ -60,9 +61,6 @@ public: AsmPrinterCtor = F; } - static unsigned getModuleMatchQuality(const Module &M); - static unsigned getJITMatchQuality(); - virtual const TargetAsmInfo *createTargetAsmInfo() const; // Pass Pipeline Configuration @@ -99,7 +97,7 @@ class ARMTargetMachine : public ARMBaseTargetMachine { const TargetData DataLayout; // Calculates type size & alignment ARMTargetLowering TLInfo; public: - ARMTargetMachine(const Module &M, const std::string &FS); + ARMTargetMachine(const Target &T, const Module &M, const std::string &FS); virtual const ARMRegisterInfo *getRegisterInfo() const { return &InstrInfo.getRegisterInfo(); @@ -125,7 +123,7 @@ class ThumbTargetMachine : public ARMBaseTargetMachine { const TargetData DataLayout; // Calculates type size & alignment ARMTargetLowering TLInfo; public: - ThumbTargetMachine(const Module &M, const std::string &FS); + ThumbTargetMachine(const Target &T, const Module &M, const std::string &FS); /// returns either Thumb1RegisterInfo of Thumb2RegisterInfo virtual const ARMBaseRegisterInfo *getRegisterInfo() const { diff --git a/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp b/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp index de6adbde55a..098f5d32257 100644 --- a/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp +++ b/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp @@ -31,6 +31,7 @@ #include "llvm/Target/TargetData.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetOptions.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSet.h" @@ -1287,7 +1288,7 @@ bool ARMAsmPrinter::doFinalization(Module &M) { /// regardless of whether the function is in SSA form. /// FunctionPass *llvm::createARMCodePrinterPass(formatted_raw_ostream &o, - ARMBaseTargetMachine &tm, + TargetMachine &tm, bool verbose) { return new ARMAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose); } @@ -1301,4 +1302,8 @@ namespace { } // Force static initialization. -extern "C" void LLVMInitializeARMAsmPrinter() { } +extern "C" void LLVMInitializeARMAsmPrinter() { + extern Target TheARMTarget, TheThumbTarget; + TargetRegistry::RegisterAsmPrinter(TheARMTarget, createARMCodePrinterPass); + TargetRegistry::RegisterAsmPrinter(TheThumbTarget, createARMCodePrinterPass); +} diff --git a/lib/Target/Alpha/AlphaTargetMachine.cpp b/lib/Target/Alpha/AlphaTargetMachine.cpp index 625d0cea543..a7a8162c124 100644 --- a/lib/Target/Alpha/AlphaTargetMachine.cpp +++ b/lib/Target/Alpha/AlphaTargetMachine.cpp @@ -22,7 +22,9 @@ using namespace llvm; // Register the targets -static RegisterTarget X("alpha", "Alpha [experimental]"); +extern Target TheAlphaTarget; +static RegisterTarget X(TheAlphaTarget, "alpha", + "Alpha [experimental]"); // No assembler printer by default AlphaTargetMachine::AsmPrinterCtorFn AlphaTargetMachine::AsmPrinterCtor = 0; @@ -34,35 +36,10 @@ const TargetAsmInfo *AlphaTargetMachine::createTargetAsmInfo() const { return new AlphaTargetAsmInfo(*this); } -unsigned AlphaTargetMachine::getModuleMatchQuality(const Module &M) { - // We strongly match "alpha*". - std::string TT = M.getTargetTriple(); - if (TT.size() >= 5 && TT[0] == 'a' && TT[1] == 'l' && TT[2] == 'p' && - TT[3] == 'h' && TT[4] == 'a') - return 20; - // If the target triple is something non-alpha, we don't match. - if (!TT.empty()) return 0; - - if (M.getEndianness() == Module::LittleEndian && - M.getPointerSize() == Module::Pointer64) - return 10; // Weak match - else if (M.getEndianness() != Module::AnyEndianness || - M.getPointerSize() != Module::AnyPointerSize) - return 0; // Match for some other target - - return getJITMatchQuality()/2; -} - -unsigned AlphaTargetMachine::getJITMatchQuality() { -#ifdef __alpha - return 10; -#else - return 0; -#endif -} - -AlphaTargetMachine::AlphaTargetMachine(const Module &M, const std::string &FS) - : DataLayout("e-f128:128:128"), +AlphaTargetMachine::AlphaTargetMachine(const Target &T, const Module &M, + const std::string &FS) + : LLVMTargetMachine(T), + DataLayout("e-f128:128:128"), FrameInfo(TargetFrameInfo::StackGrowsDown, 16, 0), JITInfo(*this), Subtarget(M, FS), diff --git a/lib/Target/Alpha/AlphaTargetMachine.h b/lib/Target/Alpha/AlphaTargetMachine.h index 75468923d88..6125ce57fc3 100644 --- a/lib/Target/Alpha/AlphaTargetMachine.h +++ b/lib/Target/Alpha/AlphaTargetMachine.h @@ -45,7 +45,7 @@ protected: static AsmPrinterCtorFn AsmPrinterCtor; public: - AlphaTargetMachine(const Module &M, const std::string &FS); + AlphaTargetMachine(const Target &T, const Module &M, const std::string &FS); virtual const AlphaInstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -61,9 +61,6 @@ public: return &JITInfo; } - static unsigned getJITMatchQuality(); - static unsigned getModuleMatchQuality(const Module &M); - // Pass Pipeline Configuration virtual bool addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel); virtual bool addPreEmitPass(PassManagerBase &PM, CodeGenOpt::Level OptLevel); diff --git a/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp b/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp index 21622dbc724..ea810df721b 100644 --- a/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp +++ b/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp @@ -24,6 +24,7 @@ #include "llvm/CodeGen/DwarfWriter.h" #include "llvm/Target/TargetAsmInfo.h" #include "llvm/Target/TargetMachine.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Mangler.h" @@ -292,9 +293,6 @@ bool AlphaAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, return false; } -// Force static initialization. -extern "C" void LLVMInitializeAlphaAsmPrinter() { } - namespace { static struct Register { Register() { @@ -302,3 +300,10 @@ namespace { } } Registrator; } + +// Force static initialization. +extern "C" void LLVMInitializeAlphaAsmPrinter() { + extern Target TheAlphaTarget; + TargetRegistry::RegisterAsmPrinter(TheAlphaTarget, + createAlphaCodePrinterPass); +} diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index caf91c882ee..b1361e8c268 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -30,9 +30,10 @@ #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/IntrinsicLowering.h" #include "llvm/Transforms/Scalar.h" -#include "llvm/Target/TargetMachineRegistry.h" #include "llvm/Target/TargetAsmInfo.h" #include "llvm/Target/TargetData.h" +#include "llvm/Target/TargetMachineRegistry.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/Support/CallSite.h" #include "llvm/Support/CFG.h" #include "llvm/Support/ErrorHandling.h" @@ -58,7 +59,8 @@ extern "C" int CBackendTargetMachineModule; int CBackendTargetMachineModule = 0; // Register the target. -static RegisterTarget X("c", "C backend"); +extern Target TheCBackendTarget; +static RegisterTarget X(TheCBackendTarget, "c", "C backend"); // Force static initialization. extern "C" void LLVMInitializeCBackendTarget() { } @@ -3186,27 +3188,27 @@ std::string CWriter::InterpretASMConstraint(InlineAsm::ConstraintInfo& c) { const char *const *table = 0; - //Grab the translation table from TargetAsmInfo if it exists + // Grab the translation table from TargetAsmInfo if it exists. if (!TAsm) { std::string E; - const TargetMachineRegistry::entry* Match = - TargetMachineRegistry::getClosestStaticTargetForModule(*TheModule, E); + const Target *Match = + TargetRegistry::getClosestStaticTargetForModule(*TheModule, E); if (Match) { - //Per platform Target Machines don't exist, so create it - // this must be done only once - const TargetMachine* TM = Match->CtorFn(*TheModule, ""); + // Per platform Target Machines don't exist, so create it; + // this must be done only once. + const TargetMachine* TM = Match->createTargetMachine(*TheModule, ""); TAsm = TM->getTargetAsmInfo(); } } if (TAsm) table = TAsm->getAsmCBE(); - //Search the translation table if it exists + // Search the translation table if it exists. for (int i = 0; table && table[i]; i += 2) if (c.Codes[0] == table[i]) return table[i+1]; - //default is identity + // Default is identity. return c.Codes[0]; } diff --git a/lib/Target/CBackend/CTargetMachine.h b/lib/Target/CBackend/CTargetMachine.h index 64b373bdf0e..b1d9e0775ea 100644 --- a/lib/Target/CBackend/CTargetMachine.h +++ b/lib/Target/CBackend/CTargetMachine.h @@ -22,18 +22,14 @@ namespace llvm { struct CTargetMachine : public TargetMachine { const TargetData DataLayout; // Calculates type size & alignment - CTargetMachine(const Module &M, const std::string &FS) - : DataLayout(&M) {} + CTargetMachine(const Target &T, const Module &M, const std::string &FS) + : TargetMachine(T), DataLayout(&M) {} virtual bool WantsWholeFile() const { return true; } virtual bool addPassesToEmitWholeFile(PassManager &PM, formatted_raw_ostream &Out, CodeGenFileType FileType, CodeGenOpt::Level OptLevel); - - // This class always works, but must be requested explicitly on - // llc command line. - static unsigned getModuleMatchQuality(const Module &M) { return 0; } virtual const TargetData *getTargetData() const { return &DataLayout; } }; diff --git a/lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp b/lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp index f0d8a36132b..0c364579137 100644 --- a/lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp +++ b/lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp @@ -37,6 +37,7 @@ #include "llvm/Target/TargetRegisterInfo.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetOptions.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringExtras.h" #include @@ -289,7 +290,7 @@ namespace { class VISIBILITY_HIDDEN LinuxAsmPrinter : public SPUAsmPrinter { DwarfWriter *DW; public: - explicit LinuxAsmPrinter(formatted_raw_ostream &O, SPUTargetMachine &TM, + explicit LinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T, bool V) : SPUAsmPrinter(O, TM, T, V), DW(0) {} @@ -599,14 +600,11 @@ bool LinuxAsmPrinter::doFinalization(Module &M) { /// that the Linux SPU assembler can deal with. /// FunctionPass *llvm::createSPUAsmPrinterPass(formatted_raw_ostream &o, - SPUTargetMachine &tm, + TargetMachine &tm, bool verbose) { return new LinuxAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose); } -// Force static initialization. -extern "C" void LLVMInitializeCellSPUAsmPrinter() { } - namespace { static struct Register { Register() { @@ -614,3 +612,9 @@ namespace { } } Registrator; } + +// Force static initialization. +extern "C" void LLVMInitializeCellSPUAsmPrinter() { + extern Target TheCellSPUTarget; + TargetRegistry::RegisterAsmPrinter(TheCellSPUTarget, createSPUAsmPrinterPass); +} diff --git a/lib/Target/CellSPU/SPU.h b/lib/Target/CellSPU/SPU.h index 02623486dc7..f76fc82e280 100644 --- a/lib/Target/CellSPU/SPU.h +++ b/lib/Target/CellSPU/SPU.h @@ -25,7 +25,7 @@ namespace llvm { FunctionPass *createSPUISelDag(SPUTargetMachine &TM); FunctionPass *createSPUAsmPrinterPass(formatted_raw_ostream &o, - SPUTargetMachine &tm, + TargetMachine &tm, bool verbose); /*--== Utility functions/predicates/etc used all over the place: --==*/ diff --git a/lib/Target/CellSPU/SPUTargetMachine.cpp b/lib/Target/CellSPU/SPUTargetMachine.cpp index 5c794c9ffa6..3a659d8e4d9 100644 --- a/lib/Target/CellSPU/SPUTargetMachine.cpp +++ b/lib/Target/CellSPU/SPUTargetMachine.cpp @@ -23,10 +23,11 @@ using namespace llvm; +extern Target TheCellSPUTarget; namespace { // Register the targets RegisterTarget - CELLSPU("cellspu", "STI CBEA Cell SPU [experimental]"); + CELLSPU(TheCellSPUTarget, "cellspu", "STI CBEA Cell SPU [experimental]"); } // No assembler printer by default @@ -47,22 +48,10 @@ SPUTargetMachine::createTargetAsmInfo() const return new SPULinuxTargetAsmInfo(*this); } -unsigned -SPUTargetMachine::getModuleMatchQuality(const Module &M) -{ - // We strongly match "spu-*" or "cellspu-*". - std::string TT = M.getTargetTriple(); - if ((TT.size() == 3 && std::string(TT.begin(), TT.begin()+3) == "spu") - || (TT.size() == 7 && std::string(TT.begin(), TT.begin()+7) == "cellspu") - || (TT.size() >= 4 && std::string(TT.begin(), TT.begin()+4) == "spu-") - || (TT.size() >= 8 && std::string(TT.begin(), TT.begin()+8) == "cellspu-")) - return 20; - - return 0; // No match at all... -} - -SPUTargetMachine::SPUTargetMachine(const Module &M, const std::string &FS) - : Subtarget(*this, M, FS), +SPUTargetMachine::SPUTargetMachine(const Target &T, const Module &M, + const std::string &FS) + : LLVMTargetMachine(T), + Subtarget(*this, M, FS), DataLayout(Subtarget.getTargetDataString()), InstrInfo(*this), FrameInfo(*this), diff --git a/lib/Target/CellSPU/SPUTargetMachine.h b/lib/Target/CellSPU/SPUTargetMachine.h index ce8e55058ee..18f525d1c8c 100644 --- a/lib/Target/CellSPU/SPUTargetMachine.h +++ b/lib/Target/CellSPU/SPUTargetMachine.h @@ -42,12 +42,12 @@ protected: // To avoid having target depend on the asmprinter stuff libraries, asmprinter // set this functions to ctor pointer at startup time if they are linked in. typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o, - SPUTargetMachine &tm, + TargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - SPUTargetMachine(const Module &M, const std::string &FS); + SPUTargetMachine(const Target &T, const Module &M, const std::string &FS); /// Return the subtarget implementation object virtual const SPUSubtarget *getSubtargetImpl() const { @@ -66,12 +66,6 @@ public: virtual TargetJITInfo *getJITInfo() { return NULL; } - - //! Module match function - /*! - Module matching function called by TargetMachineRegistry(). - */ - static unsigned getModuleMatchQuality(const Module &M); virtual SPUTargetLowering *getTargetLowering() const { return const_cast(&TLInfo); diff --git a/lib/Target/CppBackend/CPPBackend.cpp b/lib/Target/CppBackend/CPPBackend.cpp index b2d72dd228c..7b2995f9b02 100644 --- a/lib/Target/CppBackend/CPPBackend.cpp +++ b/lib/Target/CppBackend/CPPBackend.cpp @@ -81,7 +81,8 @@ extern "C" int CppBackendTargetMachineModule; int CppBackendTargetMachineModule = 0; // Register the target. -static RegisterTarget X("cpp", "C++ backend"); +extern Target TheCppBackendTarget; +static RegisterTarget X(TheCppBackendTarget, "cpp", "C++ backend"); // Force static initialization. extern "C" void LLVMInitializeCppBackendTarget() { } diff --git a/lib/Target/CppBackend/CPPTargetMachine.h b/lib/Target/CppBackend/CPPTargetMachine.h index 84a07eaece3..4d6d5fe35d8 100644 --- a/lib/Target/CppBackend/CPPTargetMachine.h +++ b/lib/Target/CppBackend/CPPTargetMachine.h @@ -24,8 +24,8 @@ class formatted_raw_ostream; struct CPPTargetMachine : public TargetMachine { const TargetData DataLayout; // Calculates type size & alignment - CPPTargetMachine(const Module &M, const std::string &FS) - : DataLayout(&M) {} + CPPTargetMachine(const Target &T, const Module &M, const std::string &FS) + : TargetMachine(T), DataLayout(&M) {} virtual bool WantsWholeFile() const { return true; } virtual bool addPassesToEmitWholeFile(PassManager &PM, @@ -33,9 +33,6 @@ struct CPPTargetMachine : public TargetMachine { CodeGenFileType FileType, CodeGenOpt::Level OptLevel); - // This class always works, but shouldn't be the default in most cases. - static unsigned getModuleMatchQuality(const Module &M) { return 1; } - virtual const TargetData *getTargetData() const { return &DataLayout; } }; diff --git a/lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp b/lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp index b8aa37ecb70..e5eedad328d 100644 --- a/lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp +++ b/lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp @@ -26,6 +26,7 @@ #include "llvm/CodeGen/DwarfWriter.h" #include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/Target/TargetAsmInfo.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/FormattedStream.h" #include "llvm/Support/Mangler.h" @@ -369,7 +370,7 @@ bool IA64AsmPrinter::doFinalization(Module &M) { /// the given target machine description. /// FunctionPass *llvm::createIA64CodePrinterPass(formatted_raw_ostream &o, - IA64TargetMachine &tm, + TargetMachine &tm, bool verbose) { return new IA64AsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose); } @@ -384,4 +385,7 @@ namespace { // Force static initialization. -extern "C" void LLVMInitializeIA64AsmPrinter() { } +extern "C" void LLVMInitializeIA64AsmPrinter() { + extern Target TheIA64Target; + TargetRegistry::RegisterAsmPrinter(TheIA64Target, createIA64CodePrinterPass); +} diff --git a/lib/Target/IA64/IA64.h b/lib/Target/IA64/IA64.h index afcbdaf4d11..e45aedaa731 100644 --- a/lib/Target/IA64/IA64.h +++ b/lib/Target/IA64/IA64.h @@ -38,7 +38,7 @@ FunctionPass *createIA64BundlingPass(IA64TargetMachine &TM); /// regardless of whether the function is in SSA form. /// FunctionPass *createIA64CodePrinterPass(formatted_raw_ostream &o, - IA64TargetMachine &tm, + TargetMachine &tm, bool verbose); } // End llvm namespace diff --git a/lib/Target/IA64/IA64TargetMachine.cpp b/lib/Target/IA64/IA64TargetMachine.cpp index 00fdd5e8a65..5355075f8b3 100644 --- a/lib/Target/IA64/IA64TargetMachine.cpp +++ b/lib/Target/IA64/IA64TargetMachine.cpp @@ -20,7 +20,8 @@ using namespace llvm; // Register the target -static RegisterTarget X("ia64", +extern Target TheIA64Target; +static RegisterTarget X(TheIA64Target, "ia64", "IA-64 (Itanium) [experimental]"); // No assembler printer by default @@ -33,36 +34,12 @@ const TargetAsmInfo *IA64TargetMachine::createTargetAsmInfo() const { return new IA64TargetAsmInfo(*this); } -unsigned IA64TargetMachine::getModuleMatchQuality(const Module &M) { - // we match [iI][aA]*64 - bool seenIA64=false; - std::string TT = M.getTargetTriple(); - - if (TT.size() >= 4) { - if( (TT[0]=='i' || TT[0]=='I') && - (TT[1]=='a' || TT[1]=='A') ) { - for(unsigned int i=2; i<(TT.size()-1); i++) - if(TT[i]=='6' && TT[i+1]=='4') - seenIA64=true; - } - - if (seenIA64) - return 20; // strong match - } - // If the target triple is something non-ia64, we don't match. - if (!TT.empty()) return 0; - -#if defined(__ia64__) || defined(__IA64__) - return 5; -#else - return 0; -#endif -} - /// IA64TargetMachine ctor - Create an LP64 architecture model /// -IA64TargetMachine::IA64TargetMachine(const Module &M, const std::string &FS) - : DataLayout("e-f80:128:128"), +IA64TargetMachine::IA64TargetMachine(const Target &T, const Module &M, + const std::string &FS) + : LLVMTargetMachine(T), + DataLayout("e-f80:128:128"), FrameInfo(TargetFrameInfo::StackGrowsDown, 16, 0), TLInfo(*this) { // FIXME? check this stuff } diff --git a/lib/Target/IA64/IA64TargetMachine.h b/lib/Target/IA64/IA64TargetMachine.h index 8340052f2c0..e82bf59c964 100644 --- a/lib/Target/IA64/IA64TargetMachine.h +++ b/lib/Target/IA64/IA64TargetMachine.h @@ -37,12 +37,12 @@ protected: // To avoid having target depend on the asmprinter stuff libraries, asmprinter // set this functions to ctor pointer at startup time if they are linked in. typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o, - IA64TargetMachine &tm, + TargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - IA64TargetMachine(const Module &M, const std::string &FS); + IA64TargetMachine(const Target &T, const Module &M, const std::string &FS); virtual const IA64InstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -55,8 +55,6 @@ public: } virtual const TargetData *getTargetData() const { return &DataLayout; } - static unsigned getModuleMatchQuality(const Module &M); - // Pass Pipeline Configuration virtual bool addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel); virtual bool addPreEmitPass(PassManagerBase &PM, CodeGenOpt::Level OptLevel); diff --git a/lib/Target/MSIL/MSILWriter.cpp b/lib/Target/MSIL/MSILWriter.cpp index 2ae1d4fba28..bedf40385d5 100644 --- a/lib/Target/MSIL/MSILWriter.cpp +++ b/lib/Target/MSIL/MSILWriter.cpp @@ -31,8 +31,8 @@ namespace { struct VISIBILITY_HIDDEN MSILTarget : public TargetMachine { const TargetData DataLayout; // Calculates type size & alignment - MSILTarget(const Module &M, const std::string &FS) - : DataLayout(&M) {} + MSILTarget(const Target &T, const Module &M, const std::string &FS) + : TargetMachine(T), DataLayout(&M) {} virtual bool WantsWholeFile() const { return true; } virtual bool addPassesToEmitWholeFile(PassManager &PM, @@ -55,7 +55,8 @@ namespace { extern "C" int MSILTargetMachineModule; int MSILTargetMachineModule = 0; -static RegisterTarget X("msil", "MSIL backend"); +extern Target TheMSILTarget; +static RegisterTarget X(TheMSILTarget, "msil", "MSIL backend"); // Force static initialization. extern "C" void LLVMInitializeMSILTarget() { } diff --git a/lib/Target/MSP430/MSP430TargetMachine.cpp b/lib/Target/MSP430/MSP430TargetMachine.cpp index 924c7e82d8e..bf259e2add5 100644 --- a/lib/Target/MSP430/MSP430TargetMachine.cpp +++ b/lib/Target/MSP430/MSP430TargetMachine.cpp @@ -32,14 +32,17 @@ int MSP430TargetMachineModule = 0; // Register the targets +extern Target TheMSP430Target; static RegisterTarget -X("msp430", "MSP430 [experimental]"); +X(TheMSP430Target, "msp430", "MSP430 [experimental]"); // Force static initialization. extern "C" void LLVMInitializeMSP430Target() { } -MSP430TargetMachine::MSP430TargetMachine(const Module &M, +MSP430TargetMachine::MSP430TargetMachine(const Target &T, + const Module &M, const std::string &FS) : + LLVMTargetMachine(T), Subtarget(*this, M, FS), // FIXME: Check TargetData string. DataLayout("e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8"), @@ -66,14 +69,3 @@ bool MSP430TargetMachine::addAssemblyEmitter(PassManagerBase &PM, return false; } -unsigned MSP430TargetMachine::getModuleMatchQuality(const Module &M) { - std::string TT = M.getTargetTriple(); - - // We strongly match msp430 - if (TT.size() >= 6 && TT[0] == 'm' && TT[1] == 's' && TT[2] == 'p' && - TT[3] == '4' && TT[4] == '3' && TT[5] == '0') - return 20; - - return 0; -} - diff --git a/lib/Target/MSP430/MSP430TargetMachine.h b/lib/Target/MSP430/MSP430TargetMachine.h index 0a5c64eb5dd..dfe827b0c64 100644 --- a/lib/Target/MSP430/MSP430TargetMachine.h +++ b/lib/Target/MSP430/MSP430TargetMachine.h @@ -41,7 +41,7 @@ protected: virtual const TargetAsmInfo *createTargetAsmInfo() const; public: - MSP430TargetMachine(const Module &M, const std::string &FS); + MSP430TargetMachine(const Target &T, const Module &M, const std::string &FS); virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } virtual const MSP430InstrInfo *getInstrInfo() const { return &InstrInfo; } @@ -60,7 +60,6 @@ public: virtual bool addAssemblyEmitter(PassManagerBase &PM, CodeGenOpt::Level OptLevel, bool Verbose, formatted_raw_ostream &Out); - static unsigned getModuleMatchQuality(const Module &M); }; // MSP430TargetMachine. } // end namespace llvm diff --git a/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp b/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp index 719c258647c..501dc6a7aba 100644 --- a/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp +++ b/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp @@ -33,6 +33,7 @@ #include "llvm/Target/TargetData.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetOptions.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Mangler.h" #include "llvm/ADT/Statistic.h" @@ -51,7 +52,7 @@ namespace { class VISIBILITY_HIDDEN MipsAsmPrinter : public AsmPrinter { const MipsSubtarget *Subtarget; public: - explicit MipsAsmPrinter(formatted_raw_ostream &O, MipsTargetMachine &TM, + explicit MipsAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T, bool V) : AsmPrinter(O, TM, T, V) { Subtarget = &TM.getSubtarget(); @@ -92,7 +93,7 @@ namespace { /// using the given target machine description. This should work /// regardless of whether the function is in SSA form. FunctionPass *llvm::createMipsCodePrinterPass(formatted_raw_ostream &o, - MipsTargetMachine &tm, + TargetMachine &tm, bool verbose) { return new MipsAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose); } @@ -584,4 +585,11 @@ namespace { } // Force static initialization. -extern "C" void LLVMInitializeMipsAsmPrinter() { } +extern "C" void LLVMInitializeMipsAsmPrinter() { + extern Target TheMipsTarget; + TargetRegistry::RegisterAsmPrinter(TheMipsTarget, createMipsCodePrinterPass); + + extern Target TheMipselTarget; + TargetRegistry::RegisterAsmPrinter(TheMipselTarget, + createMipsCodePrinterPass); +} diff --git a/lib/Target/Mips/Mips.h b/lib/Target/Mips/Mips.h index c1d6fdda513..1ff34fbcc76 100644 --- a/lib/Target/Mips/Mips.h +++ b/lib/Target/Mips/Mips.h @@ -26,7 +26,7 @@ namespace llvm { FunctionPass *createMipsISelDag(MipsTargetMachine &TM); FunctionPass *createMipsDelaySlotFillerPass(MipsTargetMachine &TM); FunctionPass *createMipsCodePrinterPass(formatted_raw_ostream &OS, - MipsTargetMachine &TM, + TargetMachine &TM, bool Verbose); } // end namespace llvm; diff --git a/lib/Target/Mips/MipsTargetMachine.cpp b/lib/Target/Mips/MipsTargetMachine.cpp index 1e6add4a545..3c2693bf16d 100644 --- a/lib/Target/Mips/MipsTargetMachine.cpp +++ b/lib/Target/Mips/MipsTargetMachine.cpp @@ -28,8 +28,12 @@ extern "C" int MipsTargetMachineModule; int MipsTargetMachineModule = 0; // Register the target. -static RegisterTarget X("mips", "Mips"); -static RegisterTarget Y("mipsel", "Mipsel"); +extern Target TheMipsTarget; +static RegisterTarget X(TheMipsTarget, "mips", "Mips"); + +extern Target TheMipselTarget; +static RegisterTarget Y(TheMipselTarget, "mipsel", + "Mipsel"); MipsTargetMachine::AsmPrinterCtorFn MipsTargetMachine::AsmPrinterCtor = 0; @@ -51,7 +55,9 @@ createTargetAsmInfo() const // an easier handling. // Using CodeModel::Large enables different CALL behavior. MipsTargetMachine:: -MipsTargetMachine(const Module &M, const std::string &FS, bool isLittle=false): +MipsTargetMachine(const Target &T, const Module &M, const std::string &FS, + bool isLittle=false): + LLVMTargetMachine(T), Subtarget(*this, M, FS, isLittle), DataLayout(isLittle ? std::string("e-p:32:32:32-i8:8:32-i16:16:32") : std::string("E-p:32:32:32-i8:8:32-i16:16:32")), @@ -70,43 +76,8 @@ MipsTargetMachine(const Module &M, const std::string &FS, bool isLittle=false): } MipselTargetMachine:: -MipselTargetMachine(const Module &M, const std::string &FS) : - MipsTargetMachine(M, FS, true) {} - -// return 0 and must specify -march to gen MIPS code. -unsigned MipsTargetMachine:: -getModuleMatchQuality(const Module &M) -{ - // We strongly match "mips*-*". - std::string TT = M.getTargetTriple(); - if (TT.size() >= 5 && std::string(TT.begin(), TT.begin()+5) == "mips-") - return 20; - - if (TT.size() >= 13 && std::string(TT.begin(), - TT.begin()+13) == "mipsallegrex-") - return 20; - - return 0; -} - -// return 0 and must specify -march to gen MIPSEL code. -unsigned MipselTargetMachine:: -getModuleMatchQuality(const Module &M) -{ - // We strongly match "mips*el-*". - std::string TT = M.getTargetTriple(); - if (TT.size() >= 7 && std::string(TT.begin(), TT.begin()+7) == "mipsel-") - return 20; - - if (TT.size() >= 15 && std::string(TT.begin(), - TT.begin()+15) == "mipsallegrexel-") - return 20; - - if (TT.size() == 3 && std::string(TT.begin(), TT.begin()+3) == "psp") - return 20; - - return 0; -} +MipselTargetMachine(const Target &T, const Module &M, const std::string &FS) : + MipsTargetMachine(T, M, FS, true) {} // Install an instruction selector pass using // the ISelDag to gen Mips code. diff --git a/lib/Target/Mips/MipsTargetMachine.h b/lib/Target/Mips/MipsTargetMachine.h index 7dd8d2befa0..6e2562a312e 100644 --- a/lib/Target/Mips/MipsTargetMachine.h +++ b/lib/Target/Mips/MipsTargetMachine.h @@ -38,12 +38,13 @@ namespace llvm { // asmprinter set this functions to ctor pointer at startup time if they are // linked in. typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o, - MipsTargetMachine &tm, + TargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - MipsTargetMachine(const Module &M, const std::string &FS, bool isLittle); + MipsTargetMachine(const Target &T, const Module &M, const std::string &FS, + bool isLittle); static void registerAsmPrinter(AsmPrinterCtorFn F) { AsmPrinterCtor = F; @@ -66,8 +67,6 @@ namespace llvm { return const_cast(&TLInfo); } - static unsigned getModuleMatchQuality(const Module &M); - // Pass Pipeline Configuration virtual bool addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel); @@ -82,7 +81,7 @@ namespace llvm { /// class MipselTargetMachine : public MipsTargetMachine { public: - MipselTargetMachine(const Module &M, const std::string &FS); + MipselTargetMachine(const Target &T, const Module &M, const std::string &FS); static unsigned getModuleMatchQuality(const Module &M); }; diff --git a/lib/Target/PIC16/PIC16TargetMachine.cpp b/lib/Target/PIC16/PIC16TargetMachine.cpp index 50deab17e50..45a61fa29be 100644 --- a/lib/Target/PIC16/PIC16TargetMachine.cpp +++ b/lib/Target/PIC16/PIC16TargetMachine.cpp @@ -32,26 +32,31 @@ int PIC16TargetMachineModule = 0; // Register the targets +extern Target ThePIC16Target; static RegisterTarget -X("pic16", "PIC16 14-bit [experimental]."); +X(ThePIC16Target, "pic16", "PIC16 14-bit [experimental]."); + +extern Target TheCooperTarget; static RegisterTarget -Y("cooper", "PIC16 Cooper [experimental]."); +Y(TheCooperTarget, "cooper", "PIC16 Cooper [experimental]."); // Force static initialization. extern "C" void LLVMInitializePIC16Target() { } // PIC16TargetMachine - Traditional PIC16 Machine. -PIC16TargetMachine::PIC16TargetMachine(const Module &M, const std::string &FS, - bool Cooper) -: Subtarget(M, FS, Cooper), +PIC16TargetMachine::PIC16TargetMachine(const Target &T, const Module &M, + const std::string &FS, bool Cooper) +: LLVMTargetMachine(T), + Subtarget(M, FS, Cooper), DataLayout("e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8"), InstrInfo(*this), TLInfo(*this), FrameInfo(TargetFrameInfo::StackGrowsUp, 8, 0) { } // CooperTargetMachine - Uses the same PIC16TargetMachine, but makes IsCooper // as true. -CooperTargetMachine::CooperTargetMachine(const Module &M, const std::string &FS) - : PIC16TargetMachine(M, FS, true) {} +CooperTargetMachine::CooperTargetMachine(const Target &T, const Module &M, + const std::string &FS) + : PIC16TargetMachine(T, M, FS, true) {} const TargetAsmInfo *PIC16TargetMachine::createTargetAsmInfo() const { diff --git a/lib/Target/PIC16/PIC16TargetMachine.h b/lib/Target/PIC16/PIC16TargetMachine.h index a0080df6c5f..f14d8fd28f8 100644 --- a/lib/Target/PIC16/PIC16TargetMachine.h +++ b/lib/Target/PIC16/PIC16TargetMachine.h @@ -41,7 +41,7 @@ protected: virtual const TargetAsmInfo *createTargetAsmInfo() const; public: - PIC16TargetMachine(const Module &M, const std::string &FS, + PIC16TargetMachine(const Target &T, const Module &M, const std::string &FS, bool Cooper = false); virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -68,7 +68,7 @@ public: /// CooperTargetMachine class CooperTargetMachine : public PIC16TargetMachine { public: - CooperTargetMachine(const Module &M, const std::string &FS); + CooperTargetMachine(const Target &T, const Module &M, const std::string &FS); }; // CooperTargetMachine. } // end namespace llvm diff --git a/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp b/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp index 7489e49ca58..f568bc1b03c 100644 --- a/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp +++ b/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp @@ -43,6 +43,7 @@ #include "llvm/Target/TargetRegisterInfo.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetOptions.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSet.h" @@ -317,7 +318,7 @@ namespace { /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux class VISIBILITY_HIDDEN PPCLinuxAsmPrinter : public PPCAsmPrinter { public: - explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, PPCTargetMachine &TM, + explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T, bool V) : PPCAsmPrinter(O, TM, T, V){} @@ -343,7 +344,7 @@ namespace { class VISIBILITY_HIDDEN PPCDarwinAsmPrinter : public PPCAsmPrinter { formatted_raw_ostream &OS; public: - explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, PPCTargetMachine &TM, + explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T, bool V) : PPCAsmPrinter(O, TM, T, V), OS(O) {} @@ -1080,7 +1081,7 @@ bool PPCDarwinAsmPrinter::doFinalization(Module &M) { /// Darwin assembler can deal with. /// FunctionPass *llvm::createPPCAsmPrinterPass(formatted_raw_ostream &o, - PPCTargetMachine &tm, + TargetMachine &tm, bool verbose) { const PPCSubtarget *Subtarget = &tm.getSubtarget(); @@ -1103,4 +1104,10 @@ extern "C" int PowerPCAsmPrinterForceLink; int PowerPCAsmPrinterForceLink = 0; // Force static initialization. -extern "C" void LLVMInitializePowerPCAsmPrinter() { } +extern "C" void LLVMInitializePowerPCAsmPrinter() { + extern Target ThePPC32Target; + TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass); + + extern Target ThePPC64Target; + TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass); +} diff --git a/lib/Target/PowerPC/PPC.h b/lib/Target/PowerPC/PPC.h index 89dc1c131e7..3aa313c73aa 100644 --- a/lib/Target/PowerPC/PPC.h +++ b/lib/Target/PowerPC/PPC.h @@ -30,7 +30,7 @@ namespace llvm { FunctionPass *createPPCBranchSelectionPass(); FunctionPass *createPPCISelDag(PPCTargetMachine &TM); FunctionPass *createPPCAsmPrinterPass(formatted_raw_ostream &OS, - PPCTargetMachine &TM, + TargetMachine &TM, bool Verbose); FunctionPass *createPPCCodeEmitterPass(PPCTargetMachine &TM, MachineCodeEmitter &MCE); diff --git a/lib/Target/PowerPC/PPCTargetMachine.cpp b/lib/Target/PowerPC/PPCTargetMachine.cpp index c261f8793ff..7e401c453f0 100644 --- a/lib/Target/PowerPC/PPCTargetMachine.cpp +++ b/lib/Target/PowerPC/PPCTargetMachine.cpp @@ -30,10 +30,13 @@ extern "C" int PowerPCTargetMachineModule; int PowerPCTargetMachineModule = 0; // Register the targets +extern Target ThePPC32Target; static RegisterTarget -X("ppc32", "PowerPC 32"); +X(ThePPC32Target, "ppc32", "PowerPC 32"); + +extern Target ThePPC64Target; static RegisterTarget -Y("ppc64", "PowerPC 64"); +Y(ThePPC64Target, "ppc64", "PowerPC 64"); // Force static initialization. extern "C" void LLVMInitializePowerPCTarget() { } @@ -48,60 +51,10 @@ const TargetAsmInfo *PPCTargetMachine::createTargetAsmInfo() const { return new PPCLinuxTargetAsmInfo(*this); } -unsigned PPC32TargetMachine::getJITMatchQuality() { -#if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER) || defined(__PPC__) - if (sizeof(void*) == 4) - return 10; -#endif - return 0; -} -unsigned PPC64TargetMachine::getJITMatchQuality() { -#if defined(__POWERPC__) || defined (__ppc__) || defined(_POWER) || defined(__PPC__) - if (sizeof(void*) == 8) - return 10; -#endif - return 0; -} - -unsigned PPC32TargetMachine::getModuleMatchQuality(const Module &M) { - // We strongly match "powerpc-*". - std::string TT = M.getTargetTriple(); - if (TT.size() >= 8 && std::string(TT.begin(), TT.begin()+8) == "powerpc-") - return 20; - - // If the target triple is something non-powerpc, we don't match. - if (!TT.empty()) return 0; - - if (M.getEndianness() == Module::BigEndian && - M.getPointerSize() == Module::Pointer32) - return 10; // Weak match - else if (M.getEndianness() != Module::AnyEndianness || - M.getPointerSize() != Module::AnyPointerSize) - return 0; // Match for some other target - - return getJITMatchQuality()/2; -} - -unsigned PPC64TargetMachine::getModuleMatchQuality(const Module &M) { - // We strongly match "powerpc64-*". - std::string TT = M.getTargetTriple(); - if (TT.size() >= 10 && std::string(TT.begin(), TT.begin()+10) == "powerpc64-") - return 20; - - if (M.getEndianness() == Module::BigEndian && - M.getPointerSize() == Module::Pointer64) - return 10; // Weak match - else if (M.getEndianness() != Module::AnyEndianness || - M.getPointerSize() != Module::AnyPointerSize) - return 0; // Match for some other target - - return getJITMatchQuality()/2; -} - - -PPCTargetMachine::PPCTargetMachine(const Module &M, const std::string &FS, - bool is64Bit) - : Subtarget(*this, M, FS, is64Bit), +PPCTargetMachine::PPCTargetMachine(const Target&T, const Module &M, + const std::string &FS, bool is64Bit) + : LLVMTargetMachine(T), + Subtarget(*this, M, FS, is64Bit), DataLayout(Subtarget.getTargetDataString()), InstrInfo(*this), FrameInfo(*this, is64Bit), JITInfo(*this, is64Bit), TLInfo(*this), InstrItins(Subtarget.getInstrItineraryData()), MachOWriterInfo(*this) { @@ -118,13 +71,15 @@ PPCTargetMachine::PPCTargetMachine(const Module &M, const std::string &FS, /// groups, which typically degrades performance. bool PPCTargetMachine::getEnableTailMergeDefault() const { return false; } -PPC32TargetMachine::PPC32TargetMachine(const Module &M, const std::string &FS) - : PPCTargetMachine(M, FS, false) { +PPC32TargetMachine::PPC32TargetMachine(const Target &T, const Module &M, + const std::string &FS) + : PPCTargetMachine(T, M, FS, false) { } -PPC64TargetMachine::PPC64TargetMachine(const Module &M, const std::string &FS) - : PPCTargetMachine(M, FS, true) { +PPC64TargetMachine::PPC64TargetMachine(const Target &T, const Module &M, + const std::string &FS) + : PPCTargetMachine(T, M, FS, true) { } diff --git a/lib/Target/PowerPC/PPCTargetMachine.h b/lib/Target/PowerPC/PPCTargetMachine.h index e6f61029f3b..794123ad164 100644 --- a/lib/Target/PowerPC/PPCTargetMachine.h +++ b/lib/Target/PowerPC/PPCTargetMachine.h @@ -45,12 +45,13 @@ protected: // To avoid having target depend on the asmprinter stuff libraries, asmprinter // set this functions to ctor pointer at startup time if they are linked in. typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o, - PPCTargetMachine &tm, + TargetMachine &m, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - PPCTargetMachine(const Module &M, const std::string &FS, bool is64Bit); + PPCTargetMachine(const Target &T, const Module &M, const std::string &FS, + bool is64Bit); virtual const PPCInstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const PPCFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -103,20 +104,14 @@ public: /// class PPC32TargetMachine : public PPCTargetMachine { public: - PPC32TargetMachine(const Module &M, const std::string &FS); - - static unsigned getJITMatchQuality(); - static unsigned getModuleMatchQuality(const Module &M); + PPC32TargetMachine(const Target &T, const Module &M, const std::string &FS); }; /// PPC64TargetMachine - PowerPC 64-bit target machine. /// class PPC64TargetMachine : public PPCTargetMachine { public: - PPC64TargetMachine(const Module &M, const std::string &FS); - - static unsigned getJITMatchQuality(); - static unsigned getModuleMatchQuality(const Module &M); + PPC64TargetMachine(const Target &T, const Module &M, const std::string &FS); }; } // end namespace llvm diff --git a/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp b/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp index c580285e35f..03735b0f41d 100644 --- a/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp +++ b/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp @@ -26,6 +26,7 @@ #include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/Target/TargetAsmInfo.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/FormattedStream.h" #include "llvm/Support/Mangler.h" @@ -359,4 +360,8 @@ namespace { } // Force static initialization. -extern "C" void LLVMInitializeSparcAsmPrinter() { } +extern "C" void LLVMInitializeSparcAsmPrinter() { + extern Target TheSparcTarget; + TargetRegistry::RegisterAsmPrinter(TheSparcTarget, + createSparcCodePrinterPass); +} diff --git a/lib/Target/Sparc/SparcTargetMachine.cpp b/lib/Target/Sparc/SparcTargetMachine.cpp index 66d549797dc..25503631134 100644 --- a/lib/Target/Sparc/SparcTargetMachine.cpp +++ b/lib/Target/Sparc/SparcTargetMachine.cpp @@ -19,7 +19,8 @@ using namespace llvm; // Register the target. -static RegisterTarget X("sparc", "SPARC"); +extern Target TheSparcTarget; +static RegisterTarget X(TheSparcTarget, "sparc", "SPARC"); // No assembler printer by default SparcTargetMachine::AsmPrinterCtorFn SparcTargetMachine::AsmPrinterCtor = 0; @@ -35,38 +36,14 @@ const TargetAsmInfo *SparcTargetMachine::createTargetAsmInfo() const { /// SparcTargetMachine ctor - Create an ILP32 architecture model /// -SparcTargetMachine::SparcTargetMachine(const Module &M, const std::string &FS) - : DataLayout("E-p:32:32-f128:128:128"), +SparcTargetMachine::SparcTargetMachine(const Target &T, const Module &M, + const std::string &FS) + : LLVMTargetMachine(T), + DataLayout("E-p:32:32-f128:128:128"), Subtarget(M, FS), TLInfo(*this), InstrInfo(Subtarget), FrameInfo(TargetFrameInfo::StackGrowsDown, 8, 0) { } -unsigned SparcTargetMachine::getModuleMatchQuality(const Module &M) { - std::string TT = M.getTargetTriple(); - if (TT.size() >= 6 && std::string(TT.begin(), TT.begin()+6) == "sparc-") - return 20; - - // If the target triple is something non-sparc, we don't match. - if (!TT.empty()) return 0; - - if (M.getEndianness() == Module::BigEndian && - M.getPointerSize() == Module::Pointer32) -#ifdef __sparc__ - return 20; // BE/32 ==> Prefer sparc on sparc -#else - return 5; // BE/32 ==> Prefer ppc elsewhere -#endif - else if (M.getEndianness() != Module::AnyEndianness || - M.getPointerSize() != Module::AnyPointerSize) - return 0; // Match for some other target - -#if defined(__sparc__) - return 10; -#else - return 0; -#endif -} - bool SparcTargetMachine::addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel) { PM.add(createSparcISelDag(*this)); diff --git a/lib/Target/Sparc/SparcTargetMachine.h b/lib/Target/Sparc/SparcTargetMachine.h index 5da4a7839d4..ca34b96365d 100644 --- a/lib/Target/Sparc/SparcTargetMachine.h +++ b/lib/Target/Sparc/SparcTargetMachine.h @@ -43,7 +43,7 @@ protected: static AsmPrinterCtorFn AsmPrinterCtor; public: - SparcTargetMachine(const Module &M, const std::string &FS); + SparcTargetMachine(const Target &T, const Module &M, const std::string &FS); virtual const SparcInstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -55,7 +55,6 @@ public: return const_cast(&TLInfo); } virtual const TargetData *getTargetData() const { return &DataLayout; } - static unsigned getModuleMatchQuality(const Module &M); // Pass Pipeline Configuration virtual bool addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel); diff --git a/lib/Target/TargetMachine.cpp b/lib/Target/TargetMachine.cpp index c487cb80530..fb95c52a999 100644 --- a/lib/Target/TargetMachine.cpp +++ b/lib/Target/TargetMachine.cpp @@ -176,8 +176,8 @@ EnableStrongPHIElim(cl::Hidden, "strong-phi-elim", // TargetMachine Class // -TargetMachine::TargetMachine() - : AsmInfo(0) { +TargetMachine::TargetMachine(const Target &T) + : TheTarget(T), AsmInfo(0) { // Typically it will be subtargets that will adjust FloatABIType from Default // to Soft or Hard. if (UseSoftFloat) diff --git a/lib/Target/TargetMachineRegistry.cpp b/lib/Target/TargetMachineRegistry.cpp deleted file mode 100644 index c1a4777c631..00000000000 --- a/lib/Target/TargetMachineRegistry.cpp +++ /dev/null @@ -1,78 +0,0 @@ -//===-- TargetMachineRegistry.cpp - Target Auto Registration Impl ---------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file exposes the RegisterTarget class, which TargetMachine -// implementations should use to register themselves with the system. This file -// also exposes the TargetMachineRegistry class, which allows tools to inspect -// all of registered targets. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Target/TargetMachineRegistry.h" -#include -using namespace llvm; - -/// 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. -const TargetMachineRegistry::entry * -TargetMachineRegistry::getClosestStaticTargetForModule(const Module &M, - std::string &Error) { - std::vector > UsableTargets; - for (Registry::iterator I = begin(), E = end(); I != E; ++I) - if (unsigned Qual = I->ModuleMatchQualityFn(M)) - UsableTargets.push_back(std::make_pair(Qual, &*I)); - - if (UsableTargets.empty()) { - Error = "No available targets are compatible with this module"; - return 0; - } else if (UsableTargets.size() == 1) - return UsableTargets.back().second; - - // Otherwise, take the best target, but make sure we don't have two equally - // good best targets. - std::sort(UsableTargets.begin(), UsableTargets.end()); - if (UsableTargets.back().first ==UsableTargets[UsableTargets.size()-2].first){ - Error = "Cannot choose between targets \"" + - std::string(UsableTargets.back().second->Name) + "\" and \"" + - std::string(UsableTargets[UsableTargets.size()-2].second->Name) + "\""; - return 0; - } - return UsableTargets.back().second; -} - -/// 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. -const TargetMachineRegistry::entry * -TargetMachineRegistry::getClosestTargetForJIT(std::string &Error) { - std::vector > UsableTargets; - for (Registry::iterator I = begin(), E = end(); I != E; ++I) - if (unsigned Qual = I->JITMatchQualityFn()) - UsableTargets.push_back(std::make_pair(Qual, &*I)); - - if (UsableTargets.empty()) { - Error = "No JIT is available for this host"; - return 0; - } else if (UsableTargets.size() == 1) - return UsableTargets.back().second; - - // Otherwise, take the best target. If there is a tie, just pick one. - unsigned MaxQual = UsableTargets.front().first; - const entry *MaxQualTarget = UsableTargets.front().second; - - for (unsigned i = 1, e = UsableTargets.size(); i != e; ++i) - if (UsableTargets[i].first > MaxQual) { - MaxQual = UsableTargets[i].first; - MaxQualTarget = UsableTargets[i].second; - } - - return MaxQualTarget; -} - diff --git a/lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h b/lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h index 9721fdcd4b9..b8a25a6bedf 100644 --- a/lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h +++ b/lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h @@ -37,7 +37,7 @@ class VISIBILITY_HIDDEN X86ATTAsmPrinter : public AsmPrinter { MCContext *Context; MCStreamer *Streamer; public: - explicit X86ATTAsmPrinter(formatted_raw_ostream &O, X86TargetMachine &TM, + explicit X86ATTAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T, bool V) : AsmPrinter(O, TM, T, V) { Subtarget = &TM.getSubtarget(); diff --git a/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp b/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp index 40b24f338fa..3fad77e8ca6 100644 --- a/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp +++ b/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp @@ -17,6 +17,7 @@ #include "X86ATTAsmPrinter.h" #include "X86IntelAsmPrinter.h" #include "X86Subtarget.h" +#include "llvm/Target/TargetRegistry.h" using namespace llvm; /// createX86CodePrinterPass - Returns a pass that prints the X86 assembly code @@ -24,7 +25,7 @@ using namespace llvm; /// machine description. /// FunctionPass *llvm::createX86CodePrinterPass(formatted_raw_ostream &o, - X86TargetMachine &tm, + TargetMachine &tm, bool verbose) { const X86Subtarget *Subtarget = &tm.getSubtarget(); @@ -45,4 +46,10 @@ extern "C" int X86AsmPrinterForceLink; int X86AsmPrinterForceLink = 0; // Force static initialization. -extern "C" void LLVMInitializeX86AsmPrinter() { } +extern "C" void LLVMInitializeX86AsmPrinter() { + extern Target TheX86_32Target; + TargetRegistry::RegisterAsmPrinter(TheX86_32Target, createX86CodePrinterPass); + + extern Target TheX86_64Target; + TargetRegistry::RegisterAsmPrinter(TheX86_64Target, createX86CodePrinterPass); +} diff --git a/lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h b/lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h index 8872869187a..603de3e3736 100644 --- a/lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h +++ b/lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h @@ -25,7 +25,7 @@ namespace llvm { struct VISIBILITY_HIDDEN X86IntelAsmPrinter : public AsmPrinter { - explicit X86IntelAsmPrinter(formatted_raw_ostream &O, X86TargetMachine &TM, + explicit X86IntelAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T, bool V) : AsmPrinter(O, TM, T, V) {} diff --git a/lib/Target/X86/X86.h b/lib/Target/X86/X86.h index ead4ce1f3f8..457e18ab0f3 100644 --- a/lib/Target/X86/X86.h +++ b/lib/Target/X86/X86.h @@ -47,7 +47,7 @@ FunctionPass *createX87FPRegKillInserterPass(); /// using the given target machine description. /// FunctionPass *createX86CodePrinterPass(formatted_raw_ostream &o, - X86TargetMachine &tm, + TargetMachine &tm, bool Verbose); /// createX86CodeEmitterPass - Return a pass that emits the collected X86 code diff --git a/lib/Target/X86/X86TargetMachine.cpp b/lib/Target/X86/X86TargetMachine.cpp index 40dc18df34b..c64084756c1 100644 --- a/lib/Target/X86/X86TargetMachine.cpp +++ b/lib/Target/X86/X86TargetMachine.cpp @@ -31,13 +31,18 @@ extern "C" int X86TargetMachineModule; int X86TargetMachineModule = 0; // Register the target. +extern Target TheX86_32Target; static RegisterTarget -X("x86", "32-bit X86: Pentium-Pro and above"); +X(TheX86_32Target, "x86", "32-bit X86: Pentium-Pro and above"); + +extern Target TheX86_64Target; static RegisterTarget -Y("x86-64", "64-bit X86: EM64T and AMD64"); +Y(TheX86_64Target, "x86-64", "64-bit X86: EM64T and AMD64"); // Force static initialization. -extern "C" void LLVMInitializeX86Target() { } +extern "C" void LLVMInitializeX86Target() { + +} // No assembler printer by default X86TargetMachine::AsmPrinterCtorFn X86TargetMachine::AsmPrinterCtor = 0; @@ -61,78 +66,23 @@ const TargetAsmInfo *X86TargetMachine::createTargetAsmInfo() const { } } -unsigned X86_32TargetMachine::getJITMatchQuality() { -#if defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86) - return 10; -#endif - return 0; -} - -unsigned X86_64TargetMachine::getJITMatchQuality() { -#if defined(__x86_64__) || defined(_M_AMD64) - return 10; -#endif - return 0; -} - -unsigned X86_32TargetMachine::getModuleMatchQuality(const Module &M) { - // We strongly match "i[3-9]86-*". - std::string TT = M.getTargetTriple(); - if (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' && - TT[4] == '-' && TT[1] - '3' < 6) - return 20; - // If the target triple is something non-X86, we don't match. - if (!TT.empty()) return 0; - - if (M.getEndianness() == Module::LittleEndian && - M.getPointerSize() == Module::Pointer32) - return 10; // Weak match - else if (M.getEndianness() != Module::AnyEndianness || - M.getPointerSize() != Module::AnyPointerSize) - return 0; // Match for some other target - - return getJITMatchQuality()/2; -} - -unsigned X86_64TargetMachine::getModuleMatchQuality(const Module &M) { - // We strongly match "x86_64-*". - std::string TT = M.getTargetTriple(); - if (TT.size() >= 7 && TT[0] == 'x' && TT[1] == '8' && TT[2] == '6' && - TT[3] == '_' && TT[4] == '6' && TT[5] == '4' && TT[6] == '-') - return 20; - - // We strongly match "amd64-*". - if (TT.size() >= 6 && TT[0] == 'a' && TT[1] == 'm' && TT[2] == 'd' && - TT[3] == '6' && TT[4] == '4' && TT[5] == '-') - return 20; - - // If the target triple is something non-X86-64, we don't match. - if (!TT.empty()) return 0; - - if (M.getEndianness() == Module::LittleEndian && - M.getPointerSize() == Module::Pointer64) - return 10; // Weak match - else if (M.getEndianness() != Module::AnyEndianness || - M.getPointerSize() != Module::AnyPointerSize) - return 0; // Match for some other target - - return getJITMatchQuality()/2; -} - -X86_32TargetMachine::X86_32TargetMachine(const Module &M, const std::string &FS) - : X86TargetMachine(M, FS, false) { +X86_32TargetMachine::X86_32TargetMachine(const Target &T, const Module &M, + const std::string &FS) + : X86TargetMachine(T, M, FS, false) { } -X86_64TargetMachine::X86_64TargetMachine(const Module &M, const std::string &FS) - : X86TargetMachine(M, FS, true) { +X86_64TargetMachine::X86_64TargetMachine(const Target &T, const Module &M, + const std::string &FS) + : X86TargetMachine(T, M, FS, true) { } /// X86TargetMachine ctor - Create an X86 target. /// -X86TargetMachine::X86TargetMachine(const Module &M, const std::string &FS, - bool is64Bit) - : Subtarget(M, FS, is64Bit), +X86TargetMachine::X86TargetMachine(const Target &T, const Module &M, + const std::string &FS, bool is64Bit) + : LLVMTargetMachine(T), + Subtarget(M, FS, is64Bit), DataLayout(Subtarget.getDataLayout()), FrameInfo(TargetFrameInfo::StackGrowsDown, Subtarget.getStackAlignment(), Subtarget.is64Bit() ? -8 : -4), diff --git a/lib/Target/X86/X86TargetMachine.h b/lib/Target/X86/X86TargetMachine.h index ea7a453a1ad..da6811bd236 100644 --- a/lib/Target/X86/X86TargetMachine.h +++ b/lib/Target/X86/X86TargetMachine.h @@ -44,12 +44,13 @@ protected: // To avoid having target depend on the asmprinter stuff libraries, asmprinter // set this functions to ctor pointer at startup time if they are linked in. typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o, - X86TargetMachine &tm, + TargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - X86TargetMachine(const Module &M, const std::string &FS, bool is64Bit); + X86TargetMachine(const Target &T, const Module &M, const std::string &FS, + bool is64Bit); virtual const X86InstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -66,9 +67,6 @@ public: return Subtarget.isTargetELF() ? &ELFWriterInfo : 0; } - static unsigned getModuleMatchQuality(const Module &M); - static unsigned getJITMatchQuality(); - static void registerAsmPrinter(AsmPrinterCtorFn F) { AsmPrinterCtor = F; } @@ -101,7 +99,7 @@ public: /// class X86_32TargetMachine : public X86TargetMachine { public: - X86_32TargetMachine(const Module &M, const std::string &FS); + X86_32TargetMachine(const Target &T, const Module &M, const std::string &FS); static unsigned getJITMatchQuality(); static unsigned getModuleMatchQuality(const Module &M); @@ -111,7 +109,7 @@ public: /// class X86_64TargetMachine : public X86TargetMachine { public: - X86_64TargetMachine(const Module &M, const std::string &FS); + X86_64TargetMachine(const Target &T, const Module &M, const std::string &FS); static unsigned getJITMatchQuality(); static unsigned getModuleMatchQuality(const Module &M); diff --git a/lib/Target/XCore/XCoreTargetMachine.cpp b/lib/Target/XCore/XCoreTargetMachine.cpp index 42b98753ecf..7fc869495a9 100644 --- a/lib/Target/XCore/XCoreTargetMachine.cpp +++ b/lib/Target/XCore/XCoreTargetMachine.cpp @@ -26,9 +26,10 @@ using namespace llvm; extern "C" int XCoreTargetMachineModule; int XCoreTargetMachineModule = 0; +extern Target TheXCoreTarget; namespace { // Register the target. - RegisterTarget X("xcore", "XCore"); + RegisterTarget X(TheXCoreTarget, "xcore", "XCore"); } // Force static initialization. @@ -40,8 +41,10 @@ const TargetAsmInfo *XCoreTargetMachine::createTargetAsmInfo() const { /// XCoreTargetMachine ctor - Create an ILP32 architecture model /// -XCoreTargetMachine::XCoreTargetMachine(const Module &M, const std::string &FS) - : Subtarget(*this, M, FS), +XCoreTargetMachine::XCoreTargetMachine(const Target &T, const Module &M, + const std::string &FS) + : LLVMTargetMachine(T), + Subtarget(*this, M, FS), DataLayout("e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-" "i16:16:32-i32:32:32-i64:32:32"), InstrInfo(), @@ -49,15 +52,6 @@ XCoreTargetMachine::XCoreTargetMachine(const Module &M, const std::string &FS) TLInfo(*this) { } -unsigned XCoreTargetMachine::getModuleMatchQuality(const Module &M) { - std::string TT = M.getTargetTriple(); - if (TT.size() >= 6 && std::string(TT.begin(), TT.begin()+6) == "xcore-") - return 20; - - // Otherwise we don't match. - return 0; -} - bool XCoreTargetMachine::addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel) { PM.add(createXCoreISelDag(*this)); diff --git a/lib/Target/XCore/XCoreTargetMachine.h b/lib/Target/XCore/XCoreTargetMachine.h index 081cf7a2a5a..e88c81b9bbd 100644 --- a/lib/Target/XCore/XCoreTargetMachine.h +++ b/lib/Target/XCore/XCoreTargetMachine.h @@ -36,7 +36,7 @@ protected: virtual const TargetAsmInfo *createTargetAsmInfo() const; public: - XCoreTargetMachine(const Module &M, const std::string &FS); + XCoreTargetMachine(const Target &T, const Module &M, const std::string &FS); virtual const XCoreInstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const XCoreFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -49,7 +49,6 @@ public: return &InstrInfo.getRegisterInfo(); } virtual const TargetData *getTargetData() const { return &DataLayout; } - static unsigned getModuleMatchQuality(const Module &M); // Pass Pipeline Configuration virtual bool addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel); diff --git a/tools/llc/llc.cpp b/tools/llc/llc.cpp index c4bb41e1f06..47acb324fb9 100644 --- a/tools/llc/llc.cpp +++ b/tools/llc/llc.cpp @@ -126,7 +126,8 @@ GetFileNameRoot(const std::string &InputFilename) { return outputFilename; } -static formatted_raw_ostream *GetOutputStream(const char *ProgName) { +static formatted_raw_ostream *GetOutputStream(const char *TargetName, + const char *ProgName) { if (OutputFilename != "") { if (OutputFilename == "-") return &fouts(); @@ -161,10 +162,10 @@ static formatted_raw_ostream *GetOutputStream(const char *ProgName) { bool Binary = false; switch (FileType) { case TargetMachine::AssemblyFile: - if (MArch->Name[0] == 'c') { - if (MArch->Name[1] == 0) + if (TargetName[0] == 'c') { + if (TargetName[1] == 0) OutputFilename += ".cbe.c"; - else if (MArch->Name[1] == 'p' && MArch->Name[2] == 'p') + else if (TargetName[1] == 'p' && TargetName[2] == 'p') OutputFilename += ".cpp"; else OutputFilename += ".s"; @@ -235,10 +236,13 @@ int main(int argc, char **argv) { // Allocate target machine. First, check whether the user has // explicitly specified an architecture to compile for. - if (MArch == 0) { + const Target *TheTarget; + if (MArch) { + TheTarget = &MArch->TheTarget; + } else { std::string Err; - MArch = TargetMachineRegistry::getClosestStaticTargetForModule(mod, Err); - if (MArch == 0) { + TheTarget = TargetRegistry::getClosestStaticTargetForModule(mod, Err); + if (TheTarget == 0) { errs() << argv[0] << ": error auto-selecting target for module '" << Err << "'. Please use the -march option to explicitly " << "pick a target.\n"; @@ -256,12 +260,13 @@ int main(int argc, char **argv) { FeaturesStr = Features.getString(); } - std::auto_ptr target(MArch->CtorFn(mod, FeaturesStr)); + std::auto_ptr + target(TheTarget->createTargetMachine(mod, FeaturesStr)); assert(target.get() && "Could not allocate target machine!"); TargetMachine &Target = *target.get(); // Figure out where we are going to send the output... - formatted_raw_ostream *Out = GetOutputStream(argv[0]); + formatted_raw_ostream *Out = GetOutputStream(TheTarget->getName(), argv[0]); if (Out == 0) return 1; CodeGenOpt::Level OLvl = CodeGenOpt::Default; diff --git a/tools/lto/LTOCodeGenerator.cpp b/tools/lto/LTOCodeGenerator.cpp index 9596057733e..5176359e5d0 100644 --- a/tools/lto/LTOCodeGenerator.cpp +++ b/tools/lto/LTOCodeGenerator.cpp @@ -329,9 +329,9 @@ bool LTOCodeGenerator::determineTarget(std::string& errMsg) if ( _target == NULL ) { // create target machine from info for merged modules Module* mergedModule = _linker.getModule(); - const TargetMachineRegistry::entry* march = - TargetMachineRegistry::getClosestStaticTargetForModule( - *mergedModule, errMsg); + const Target *march = + TargetRegistry::getClosestStaticTargetForModule(*mergedModule, + errMsg); if ( march == NULL ) return true; @@ -352,7 +352,7 @@ bool LTOCodeGenerator::determineTarget(std::string& errMsg) // construct LTModule, hand over ownership of module and target std::string FeatureStr = getFeatureString(_linker.getModule()->getTargetTriple().c_str()); - _target = march->CtorFn(*mergedModule, FeatureStr.c_str()); + _target = march->createTargetMachine(*mergedModule, FeatureStr.c_str()); } return false; } diff --git a/tools/lto/LTOModule.cpp b/tools/lto/LTOModule.cpp index 38ee1cc7a28..be6543c8f7f 100644 --- a/tools/lto/LTOModule.cpp +++ b/tools/lto/LTOModule.cpp @@ -147,15 +147,15 @@ LTOModule* LTOModule::makeLTOModule(MemoryBuffer* buffer, if ( !m ) return NULL; // find machine architecture for this module - const TargetMachineRegistry::entry* march = - TargetMachineRegistry::getClosestStaticTargetForModule(*m, errMsg); + const Target* march = + TargetRegistry::getClosestStaticTargetForModule(*m, errMsg); if ( march == NULL ) return NULL; // construct LTModule, hand over ownership of module and target std::string FeatureStr = getFeatureString(m->getTargetTriple().c_str()); - TargetMachine* target = march->CtorFn(*m, FeatureStr); + TargetMachine* target = march->createTargetMachine(*m, FeatureStr); return new LTOModule(m.take(), target); } -- 2.11.0