diff options
Diffstat (limited to 'llvm')
53 files changed, 557 insertions, 306 deletions
diff --git a/llvm/include/llvm/Target/TargetMachine.h b/llvm/include/llvm/Target/TargetMachine.h index 5ac1d69941d..ce293d5114d 100644 --- a/llvm/include/llvm/Target/TargetMachine.h +++ b/llvm/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/llvm/include/llvm/Target/TargetMachineRegistry.h b/llvm/include/llvm/Target/TargetMachineRegistry.h index 6b78a58ab0e..b7ea448b203 100644 --- a/llvm/include/llvm/Target/TargetMachineRegistry.h +++ b/llvm/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/llvm/include/llvm/Target/TargetRegistry.h b/llvm/include/llvm/Target/TargetRegistry.h index 95cf35c4558..204d5b0c8f5 100644 --- a/llvm/include/llvm/Target/TargetRegistry.h +++ b/llvm/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/llvm/include/llvm/Target/TargetSelect.h b/llvm/include/llvm/Target/TargetSelect.h index a360f731ba8..19b660b52da 100644 --- a/llvm/include/llvm/Target/TargetSelect.h +++ b/llvm/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; diff --git a/llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp b/llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp index a4157bcd7b2..24dd0136398 100644 --- a/llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp +++ b/llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp @@ -45,16 +45,16 @@ ExecutionEngine *JIT::createJIT(ModuleProvider *MP, std::string *ErrorStr, JITMemoryManager *JMM, CodeGenOpt::Level OptLevel, bool AllocateGVsWithCode) { - const Target *TheTarget; - if (MArch == 0) { + const TargetMachineRegistry::entry *TheArch = MArch; + if (TheArch == 0) { std::string Error; - TheTarget = TargetRegistry::getClosestTargetForJIT(Error); - if (TheTarget == 0) { + TheArch = TargetMachineRegistry::getClosestTargetForJIT(Error); + if (TheArch == 0) { if (ErrorStr) *ErrorStr = Error; return 0; } - } else if (TheTarget->getJITMatchQuality() == 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"; @@ -71,8 +71,7 @@ ExecutionEngine *JIT::createJIT(ModuleProvider *MP, std::string *ErrorStr, } // Allocate a target... - TargetMachine *Target = - TheTarget->createTargetMachine(*MP->getModule(), FeaturesStr); + TargetMachine *Target = TheArch->CtorFn(*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/llvm/lib/Support/TargetRegistry.cpp b/llvm/lib/Support/TargetRegistry.cpp index 77cf2dd72cf..258d703d16d 100644 --- a/llvm/lib/Support/TargetRegistry.cpp +++ b/llvm/lib/Support/TargetRegistry.cpp @@ -111,13 +111,15 @@ 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/llvm/lib/Target/ARM/ARM.h b/llvm/lib/Target/ARM/ARM.h index 1b5b828395a..f6ae6806fda 100644 --- a/llvm/lib/Target/ARM/ARM.h +++ b/llvm/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, - TargetMachine &TM, + ARMBaseTargetMachine &TM, bool Verbose); FunctionPass *createARMCodeEmitterPass(ARMBaseTargetMachine &TM, MachineCodeEmitter &MCE); diff --git a/llvm/lib/Target/ARM/ARMTargetMachine.cpp b/llvm/lib/Target/ARM/ARMTargetMachine.cpp index ad800207382..932659d8b66 100644 --- a/llvm/lib/Target/ARM/ARMTargetMachine.cpp +++ b/llvm/lib/Target/ARM/ARMTargetMachine.cpp @@ -36,11 +36,8 @@ extern "C" int ARMTargetMachineModule; int ARMTargetMachineModule = 0; // Register the target. -extern Target TheARMTarget; -static RegisterTarget<ARMTargetMachine> X(TheARMTarget, "arm", "ARM"); - -extern Target TheThumbTarget; -static RegisterTarget<ThumbTargetMachine> Y(TheThumbTarget, "thumb", "Thumb"); +static RegisterTarget<ARMTargetMachine> X("arm", "ARM"); +static RegisterTarget<ThumbTargetMachine> Y("thumb", "Thumb"); // Force static initialization. extern "C" void LLVMInitializeARMTarget() { } @@ -48,32 +45,57 @@ 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 Target &T, - const Module &M, +ARMBaseTargetMachine::ARMBaseTargetMachine(const Module &M, const std::string &FS, bool isThumb) - : LLVMTargetMachine(T), - Subtarget(M, FS, isThumb), + : Subtarget(M, FS, isThumb), FrameInfo(Subtarget), JITInfo(), InstrItins(Subtarget.getInstrItineraryData()) { DefRelocModel = getRelocationModel(); } -ARMTargetMachine::ARMTargetMachine(const Target &T, const Module &M, - const std::string &FS) - : ARMBaseTargetMachine(T, M, FS, false), InstrInfo(Subtarget), +ARMTargetMachine::ARMTargetMachine(const Module &M, const std::string &FS) + : ARMBaseTargetMachine(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 Target &T, const Module &M, - const std::string &FS) - : ARMBaseTargetMachine(T, M, FS, true), +ThumbTargetMachine::ThumbTargetMachine(const Module &M, const std::string &FS) + : ARMBaseTargetMachine(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") : @@ -87,6 +109,32 @@ ThumbTargetMachine::ThumbTargetMachine(const Target &T, const Module &M, 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/llvm/lib/Target/ARM/ARMTargetMachine.h b/llvm/lib/Target/ARM/ARMTargetMachine.h index 3fe259ad08d..56b18ae36af 100644 --- a/llvm/lib/Target/ARM/ARMTargetMachine.h +++ b/llvm/lib/Target/ARM/ARMTargetMachine.h @@ -42,13 +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, - TargetMachine &tm, + ARMBaseTargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - ARMBaseTargetMachine(const Target &T, const Module &M, const std::string &FS, - bool isThumb); + ARMBaseTargetMachine(const Module &M, const std::string &FS, bool isThumb); virtual const ARMFrameInfo *getFrameInfo() const { return &FrameInfo; } virtual ARMJITInfo *getJITInfo() { return &JITInfo; } @@ -61,6 +60,9 @@ public: AsmPrinterCtor = F; } + static unsigned getModuleMatchQuality(const Module &M); + static unsigned getJITMatchQuality(); + virtual const TargetAsmInfo *createTargetAsmInfo() const; // Pass Pipeline Configuration @@ -97,7 +99,7 @@ class ARMTargetMachine : public ARMBaseTargetMachine { const TargetData DataLayout; // Calculates type size & alignment ARMTargetLowering TLInfo; public: - ARMTargetMachine(const Target &T, const Module &M, const std::string &FS); + ARMTargetMachine(const Module &M, const std::string &FS); virtual const ARMRegisterInfo *getRegisterInfo() const { return &InstrInfo.getRegisterInfo(); @@ -123,7 +125,7 @@ class ThumbTargetMachine : public ARMBaseTargetMachine { const TargetData DataLayout; // Calculates type size & alignment ARMTargetLowering TLInfo; public: - ThumbTargetMachine(const Target &T, const Module &M, const std::string &FS); + ThumbTargetMachine(const Module &M, const std::string &FS); /// returns either Thumb1RegisterInfo of Thumb2RegisterInfo virtual const ARMBaseRegisterInfo *getRegisterInfo() const { diff --git a/llvm/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp b/llvm/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp index 098f5d32257..de6adbde55a 100644 --- a/llvm/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp +++ b/llvm/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp @@ -31,7 +31,6 @@ #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" @@ -1288,7 +1287,7 @@ bool ARMAsmPrinter::doFinalization(Module &M) { /// regardless of whether the function is in SSA form. /// FunctionPass *llvm::createARMCodePrinterPass(formatted_raw_ostream &o, - TargetMachine &tm, + ARMBaseTargetMachine &tm, bool verbose) { return new ARMAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose); } @@ -1302,8 +1301,4 @@ namespace { } // Force static initialization. -extern "C" void LLVMInitializeARMAsmPrinter() { - extern Target TheARMTarget, TheThumbTarget; - TargetRegistry::RegisterAsmPrinter(TheARMTarget, createARMCodePrinterPass); - TargetRegistry::RegisterAsmPrinter(TheThumbTarget, createARMCodePrinterPass); -} +extern "C" void LLVMInitializeARMAsmPrinter() { } diff --git a/llvm/lib/Target/Alpha/AlphaTargetMachine.cpp b/llvm/lib/Target/Alpha/AlphaTargetMachine.cpp index a7a8162c124..625d0cea543 100644 --- a/llvm/lib/Target/Alpha/AlphaTargetMachine.cpp +++ b/llvm/lib/Target/Alpha/AlphaTargetMachine.cpp @@ -22,9 +22,7 @@ using namespace llvm; // Register the targets -extern Target TheAlphaTarget; -static RegisterTarget<AlphaTargetMachine> X(TheAlphaTarget, "alpha", - "Alpha [experimental]"); +static RegisterTarget<AlphaTargetMachine> X("alpha", "Alpha [experimental]"); // No assembler printer by default AlphaTargetMachine::AsmPrinterCtorFn AlphaTargetMachine::AsmPrinterCtor = 0; @@ -36,10 +34,35 @@ const TargetAsmInfo *AlphaTargetMachine::createTargetAsmInfo() const { return new AlphaTargetAsmInfo(*this); } -AlphaTargetMachine::AlphaTargetMachine(const Target &T, const Module &M, - const std::string &FS) - : LLVMTargetMachine(T), - DataLayout("e-f128:128:128"), +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"), FrameInfo(TargetFrameInfo::StackGrowsDown, 16, 0), JITInfo(*this), Subtarget(M, FS), diff --git a/llvm/lib/Target/Alpha/AlphaTargetMachine.h b/llvm/lib/Target/Alpha/AlphaTargetMachine.h index 6125ce57fc3..75468923d88 100644 --- a/llvm/lib/Target/Alpha/AlphaTargetMachine.h +++ b/llvm/lib/Target/Alpha/AlphaTargetMachine.h @@ -45,7 +45,7 @@ protected: static AsmPrinterCtorFn AsmPrinterCtor; public: - AlphaTargetMachine(const Target &T, const Module &M, const std::string &FS); + AlphaTargetMachine(const Module &M, const std::string &FS); virtual const AlphaInstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -61,6 +61,9 @@ 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/llvm/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp b/llvm/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp index ea810df721b..21622dbc724 100644 --- a/llvm/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp +++ b/llvm/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp @@ -24,7 +24,6 @@ #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" @@ -293,6 +292,9 @@ bool AlphaAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, return false; } +// Force static initialization. +extern "C" void LLVMInitializeAlphaAsmPrinter() { } + namespace { static struct Register { Register() { @@ -300,10 +302,3 @@ namespace { } } Registrator; } - -// Force static initialization. -extern "C" void LLVMInitializeAlphaAsmPrinter() { - extern Target TheAlphaTarget; - TargetRegistry::RegisterAsmPrinter(TheAlphaTarget, - createAlphaCodePrinterPass); -} diff --git a/llvm/lib/Target/CBackend/CBackend.cpp b/llvm/lib/Target/CBackend/CBackend.cpp index b1361e8c268..caf91c882ee 100644 --- a/llvm/lib/Target/CBackend/CBackend.cpp +++ b/llvm/lib/Target/CBackend/CBackend.cpp @@ -30,10 +30,9 @@ #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" @@ -59,8 +58,7 @@ extern "C" int CBackendTargetMachineModule; int CBackendTargetMachineModule = 0; // Register the target. -extern Target TheCBackendTarget; -static RegisterTarget<CTargetMachine> X(TheCBackendTarget, "c", "C backend"); +static RegisterTarget<CTargetMachine> X("c", "C backend"); // Force static initialization. extern "C" void LLVMInitializeCBackendTarget() { } @@ -3188,27 +3186,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 Target *Match = - TargetRegistry::getClosestStaticTargetForModule(*TheModule, E); + const TargetMachineRegistry::entry* Match = + TargetMachineRegistry::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->createTargetMachine(*TheModule, ""); + //Per platform Target Machines don't exist, so create it + // this must be done only once + const TargetMachine* TM = Match->CtorFn(*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/llvm/lib/Target/CBackend/CTargetMachine.h b/llvm/lib/Target/CBackend/CTargetMachine.h index b1d9e0775ea..64b373bdf0e 100644 --- a/llvm/lib/Target/CBackend/CTargetMachine.h +++ b/llvm/lib/Target/CBackend/CTargetMachine.h @@ -22,14 +22,18 @@ namespace llvm { struct CTargetMachine : public TargetMachine { const TargetData DataLayout; // Calculates type size & alignment - CTargetMachine(const Target &T, const Module &M, const std::string &FS) - : TargetMachine(T), DataLayout(&M) {} + CTargetMachine(const Module &M, const std::string &FS) + : 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/llvm/lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp b/llvm/lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp index 0c364579137..f0d8a36132b 100644 --- a/llvm/lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp +++ b/llvm/lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp @@ -37,7 +37,6 @@ #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 <set> @@ -290,7 +289,7 @@ namespace { class VISIBILITY_HIDDEN LinuxAsmPrinter : public SPUAsmPrinter { DwarfWriter *DW; public: - explicit LinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, + explicit LinuxAsmPrinter(formatted_raw_ostream &O, SPUTargetMachine &TM, const TargetAsmInfo *T, bool V) : SPUAsmPrinter(O, TM, T, V), DW(0) {} @@ -600,11 +599,14 @@ bool LinuxAsmPrinter::doFinalization(Module &M) { /// that the Linux SPU assembler can deal with. /// FunctionPass *llvm::createSPUAsmPrinterPass(formatted_raw_ostream &o, - TargetMachine &tm, + SPUTargetMachine &tm, bool verbose) { return new LinuxAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose); } +// Force static initialization. +extern "C" void LLVMInitializeCellSPUAsmPrinter() { } + namespace { static struct Register { Register() { @@ -612,9 +614,3 @@ namespace { } } Registrator; } - -// Force static initialization. -extern "C" void LLVMInitializeCellSPUAsmPrinter() { - extern Target TheCellSPUTarget; - TargetRegistry::RegisterAsmPrinter(TheCellSPUTarget, createSPUAsmPrinterPass); -} diff --git a/llvm/lib/Target/CellSPU/SPU.h b/llvm/lib/Target/CellSPU/SPU.h index f76fc82e280..02623486dc7 100644 --- a/llvm/lib/Target/CellSPU/SPU.h +++ b/llvm/lib/Target/CellSPU/SPU.h @@ -25,7 +25,7 @@ namespace llvm { FunctionPass *createSPUISelDag(SPUTargetMachine &TM); FunctionPass *createSPUAsmPrinterPass(formatted_raw_ostream &o, - TargetMachine &tm, + SPUTargetMachine &tm, bool verbose); /*--== Utility functions/predicates/etc used all over the place: --==*/ diff --git a/llvm/lib/Target/CellSPU/SPUTargetMachine.cpp b/llvm/lib/Target/CellSPU/SPUTargetMachine.cpp index 3a659d8e4d9..5c794c9ffa6 100644 --- a/llvm/lib/Target/CellSPU/SPUTargetMachine.cpp +++ b/llvm/lib/Target/CellSPU/SPUTargetMachine.cpp @@ -23,11 +23,10 @@ using namespace llvm; -extern Target TheCellSPUTarget; namespace { // Register the targets RegisterTarget<SPUTargetMachine> - CELLSPU(TheCellSPUTarget, "cellspu", "STI CBEA Cell SPU [experimental]"); + CELLSPU("cellspu", "STI CBEA Cell SPU [experimental]"); } // No assembler printer by default @@ -48,10 +47,22 @@ SPUTargetMachine::createTargetAsmInfo() const return new SPULinuxTargetAsmInfo(*this); } -SPUTargetMachine::SPUTargetMachine(const Target &T, const Module &M, - const std::string &FS) - : LLVMTargetMachine(T), - Subtarget(*this, M, FS), +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), DataLayout(Subtarget.getTargetDataString()), InstrInfo(*this), FrameInfo(*this), diff --git a/llvm/lib/Target/CellSPU/SPUTargetMachine.h b/llvm/lib/Target/CellSPU/SPUTargetMachine.h index 18f525d1c8c..ce8e55058ee 100644 --- a/llvm/lib/Target/CellSPU/SPUTargetMachine.h +++ b/llvm/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, - TargetMachine &tm, + SPUTargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - SPUTargetMachine(const Target &T, const Module &M, const std::string &FS); + SPUTargetMachine(const Module &M, const std::string &FS); /// Return the subtarget implementation object virtual const SPUSubtarget *getSubtargetImpl() const { @@ -66,6 +66,12 @@ 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<SPUTargetLowering*>(&TLInfo); diff --git a/llvm/lib/Target/CppBackend/CPPBackend.cpp b/llvm/lib/Target/CppBackend/CPPBackend.cpp index 7b2995f9b02..b2d72dd228c 100644 --- a/llvm/lib/Target/CppBackend/CPPBackend.cpp +++ b/llvm/lib/Target/CppBackend/CPPBackend.cpp @@ -81,8 +81,7 @@ extern "C" int CppBackendTargetMachineModule; int CppBackendTargetMachineModule = 0; // Register the target. -extern Target TheCppBackendTarget; -static RegisterTarget<CPPTargetMachine> X(TheCppBackendTarget, "cpp", "C++ backend"); +static RegisterTarget<CPPTargetMachine> X("cpp", "C++ backend"); // Force static initialization. extern "C" void LLVMInitializeCppBackendTarget() { } diff --git a/llvm/lib/Target/CppBackend/CPPTargetMachine.h b/llvm/lib/Target/CppBackend/CPPTargetMachine.h index 4d6d5fe35d8..84a07eaece3 100644 --- a/llvm/lib/Target/CppBackend/CPPTargetMachine.h +++ b/llvm/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 Target &T, const Module &M, const std::string &FS) - : TargetMachine(T), DataLayout(&M) {} + CPPTargetMachine(const Module &M, const std::string &FS) + : DataLayout(&M) {} virtual bool WantsWholeFile() const { return true; } virtual bool addPassesToEmitWholeFile(PassManager &PM, @@ -33,6 +33,9 @@ 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/llvm/lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp b/llvm/lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp index e5eedad328d..b8aa37ecb70 100644 --- a/llvm/lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp +++ b/llvm/lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp @@ -26,7 +26,6 @@ #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" @@ -370,7 +369,7 @@ bool IA64AsmPrinter::doFinalization(Module &M) { /// the given target machine description. /// FunctionPass *llvm::createIA64CodePrinterPass(formatted_raw_ostream &o, - TargetMachine &tm, + IA64TargetMachine &tm, bool verbose) { return new IA64AsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose); } @@ -385,7 +384,4 @@ namespace { // Force static initialization. -extern "C" void LLVMInitializeIA64AsmPrinter() { - extern Target TheIA64Target; - TargetRegistry::RegisterAsmPrinter(TheIA64Target, createIA64CodePrinterPass); -} +extern "C" void LLVMInitializeIA64AsmPrinter() { } diff --git a/llvm/lib/Target/IA64/IA64.h b/llvm/lib/Target/IA64/IA64.h index e45aedaa731..afcbdaf4d11 100644 --- a/llvm/lib/Target/IA64/IA64.h +++ b/llvm/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, - TargetMachine &tm, + IA64TargetMachine &tm, bool verbose); } // End llvm namespace diff --git a/llvm/lib/Target/IA64/IA64TargetMachine.cpp b/llvm/lib/Target/IA64/IA64TargetMachine.cpp index 5355075f8b3..00fdd5e8a65 100644 --- a/llvm/lib/Target/IA64/IA64TargetMachine.cpp +++ b/llvm/lib/Target/IA64/IA64TargetMachine.cpp @@ -20,8 +20,7 @@ using namespace llvm; // Register the target -extern Target TheIA64Target; -static RegisterTarget<IA64TargetMachine> X(TheIA64Target, "ia64", +static RegisterTarget<IA64TargetMachine> X("ia64", "IA-64 (Itanium) [experimental]"); // No assembler printer by default @@ -34,12 +33,36 @@ 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 Target &T, const Module &M, - const std::string &FS) - : LLVMTargetMachine(T), - DataLayout("e-f80:128:128"), +IA64TargetMachine::IA64TargetMachine(const Module &M, const std::string &FS) + : DataLayout("e-f80:128:128"), FrameInfo(TargetFrameInfo::StackGrowsDown, 16, 0), TLInfo(*this) { // FIXME? check this stuff } diff --git a/llvm/lib/Target/IA64/IA64TargetMachine.h b/llvm/lib/Target/IA64/IA64TargetMachine.h index e82bf59c964..8340052f2c0 100644 --- a/llvm/lib/Target/IA64/IA64TargetMachine.h +++ b/llvm/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, - TargetMachine &tm, + IA64TargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - IA64TargetMachine(const Target &T, const Module &M, const std::string &FS); + IA64TargetMachine(const Module &M, const std::string &FS); virtual const IA64InstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -55,6 +55,8 @@ 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/llvm/lib/Target/MSIL/MSILWriter.cpp b/llvm/lib/Target/MSIL/MSILWriter.cpp index bedf40385d5..2ae1d4fba28 100644 --- a/llvm/lib/Target/MSIL/MSILWriter.cpp +++ b/llvm/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 Target &T, const Module &M, const std::string &FS) - : TargetMachine(T), DataLayout(&M) {} + MSILTarget(const Module &M, const std::string &FS) + : DataLayout(&M) {} virtual bool WantsWholeFile() const { return true; } virtual bool addPassesToEmitWholeFile(PassManager &PM, @@ -55,8 +55,7 @@ namespace { extern "C" int MSILTargetMachineModule; int MSILTargetMachineModule = 0; -extern Target TheMSILTarget; -static RegisterTarget<MSILTarget> X(TheMSILTarget, "msil", "MSIL backend"); +static RegisterTarget<MSILTarget> X("msil", "MSIL backend"); // Force static initialization. extern "C" void LLVMInitializeMSILTarget() { } diff --git a/llvm/lib/Target/MSP430/MSP430TargetMachine.cpp b/llvm/lib/Target/MSP430/MSP430TargetMachine.cpp index bf259e2add5..924c7e82d8e 100644 --- a/llvm/lib/Target/MSP430/MSP430TargetMachine.cpp +++ b/llvm/lib/Target/MSP430/MSP430TargetMachine.cpp @@ -32,17 +32,14 @@ int MSP430TargetMachineModule = 0; // Register the targets -extern Target TheMSP430Target; static RegisterTarget<MSP430TargetMachine> -X(TheMSP430Target, "msp430", "MSP430 [experimental]"); +X("msp430", "MSP430 [experimental]"); // Force static initialization. extern "C" void LLVMInitializeMSP430Target() { } -MSP430TargetMachine::MSP430TargetMachine(const Target &T, - const Module &M, +MSP430TargetMachine::MSP430TargetMachine(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"), @@ -69,3 +66,14 @@ 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/llvm/lib/Target/MSP430/MSP430TargetMachine.h b/llvm/lib/Target/MSP430/MSP430TargetMachine.h index dfe827b0c64..0a5c64eb5dd 100644 --- a/llvm/lib/Target/MSP430/MSP430TargetMachine.h +++ b/llvm/lib/Target/MSP430/MSP430TargetMachine.h @@ -41,7 +41,7 @@ protected: virtual const TargetAsmInfo *createTargetAsmInfo() const; public: - MSP430TargetMachine(const Target &T, const Module &M, const std::string &FS); + MSP430TargetMachine(const Module &M, const std::string &FS); virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } virtual const MSP430InstrInfo *getInstrInfo() const { return &InstrInfo; } @@ -60,6 +60,7 @@ 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/llvm/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp b/llvm/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp index 501dc6a7aba..719c258647c 100644 --- a/llvm/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp +++ b/llvm/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp @@ -33,7 +33,6 @@ #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" @@ -52,7 +51,7 @@ namespace { class VISIBILITY_HIDDEN MipsAsmPrinter : public AsmPrinter { const MipsSubtarget *Subtarget; public: - explicit MipsAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, + explicit MipsAsmPrinter(formatted_raw_ostream &O, MipsTargetMachine &TM, const TargetAsmInfo *T, bool V) : AsmPrinter(O, TM, T, V) { Subtarget = &TM.getSubtarget<MipsSubtarget>(); @@ -93,7 +92,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, - TargetMachine &tm, + MipsTargetMachine &tm, bool verbose) { return new MipsAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose); } @@ -585,11 +584,4 @@ namespace { } // Force static initialization. -extern "C" void LLVMInitializeMipsAsmPrinter() { - extern Target TheMipsTarget; - TargetRegistry::RegisterAsmPrinter(TheMipsTarget, createMipsCodePrinterPass); - - extern Target TheMipselTarget; - TargetRegistry::RegisterAsmPrinter(TheMipselTarget, - createMipsCodePrinterPass); -} +extern "C" void LLVMInitializeMipsAsmPrinter() { } diff --git a/llvm/lib/Target/Mips/Mips.h b/llvm/lib/Target/Mips/Mips.h index 1ff34fbcc76..c1d6fdda513 100644 --- a/llvm/lib/Target/Mips/Mips.h +++ b/llvm/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, - TargetMachine &TM, + MipsTargetMachine &TM, bool Verbose); } // end namespace llvm; diff --git a/llvm/lib/Target/Mips/MipsTargetMachine.cpp b/llvm/lib/Target/Mips/MipsTargetMachine.cpp index 3c2693bf16d..1e6add4a545 100644 --- a/llvm/lib/Target/Mips/MipsTargetMachine.cpp +++ b/llvm/lib/Target/Mips/MipsTargetMachine.cpp @@ -28,12 +28,8 @@ extern "C" int MipsTargetMachineModule; int MipsTargetMachineModule = 0; // Register the target. -extern Target TheMipsTarget; -static RegisterTarget<MipsTargetMachine> X(TheMipsTarget, "mips", "Mips"); - -extern Target TheMipselTarget; -static RegisterTarget<MipselTargetMachine> Y(TheMipselTarget, "mipsel", - "Mipsel"); +static RegisterTarget<MipsTargetMachine> X("mips", "Mips"); +static RegisterTarget<MipselTargetMachine> Y("mipsel", "Mipsel"); MipsTargetMachine::AsmPrinterCtorFn MipsTargetMachine::AsmPrinterCtor = 0; @@ -55,9 +51,7 @@ createTargetAsmInfo() const // an easier handling. // Using CodeModel::Large enables different CALL behavior. MipsTargetMachine:: -MipsTargetMachine(const Target &T, const Module &M, const std::string &FS, - bool isLittle=false): - LLVMTargetMachine(T), +MipsTargetMachine(const Module &M, const std::string &FS, bool isLittle=false): 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")), @@ -76,8 +70,43 @@ MipsTargetMachine(const Target &T, const Module &M, const std::string &FS, } MipselTargetMachine:: -MipselTargetMachine(const Target &T, const Module &M, const std::string &FS) : - MipsTargetMachine(T, M, FS, true) {} +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; +} // Install an instruction selector pass using // the ISelDag to gen Mips code. diff --git a/llvm/lib/Target/Mips/MipsTargetMachine.h b/llvm/lib/Target/Mips/MipsTargetMachine.h index 6e2562a312e..7dd8d2befa0 100644 --- a/llvm/lib/Target/Mips/MipsTargetMachine.h +++ b/llvm/lib/Target/Mips/MipsTargetMachine.h @@ -38,13 +38,12 @@ namespace llvm { // asmprinter set this functions to ctor pointer at startup time if they are // linked in. typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o, - TargetMachine &tm, + MipsTargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - MipsTargetMachine(const Target &T, const Module &M, const std::string &FS, - bool isLittle); + MipsTargetMachine(const Module &M, const std::string &FS, bool isLittle); static void registerAsmPrinter(AsmPrinterCtorFn F) { AsmPrinterCtor = F; @@ -67,6 +66,8 @@ namespace llvm { return const_cast<MipsTargetLowering*>(&TLInfo); } + static unsigned getModuleMatchQuality(const Module &M); + // Pass Pipeline Configuration virtual bool addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel); @@ -81,7 +82,7 @@ namespace llvm { /// class MipselTargetMachine : public MipsTargetMachine { public: - MipselTargetMachine(const Target &T, const Module &M, const std::string &FS); + MipselTargetMachine(const Module &M, const std::string &FS); static unsigned getModuleMatchQuality(const Module &M); }; diff --git a/llvm/lib/Target/PIC16/PIC16TargetMachine.cpp b/llvm/lib/Target/PIC16/PIC16TargetMachine.cpp index 45a61fa29be..50deab17e50 100644 --- a/llvm/lib/Target/PIC16/PIC16TargetMachine.cpp +++ b/llvm/lib/Target/PIC16/PIC16TargetMachine.cpp @@ -32,31 +32,26 @@ int PIC16TargetMachineModule = 0; // Register the targets -extern Target ThePIC16Target; static RegisterTarget<PIC16TargetMachine> -X(ThePIC16Target, "pic16", "PIC16 14-bit [experimental]."); - -extern Target TheCooperTarget; +X("pic16", "PIC16 14-bit [experimental]."); static RegisterTarget<CooperTargetMachine> -Y(TheCooperTarget, "cooper", "PIC16 Cooper [experimental]."); +Y("cooper", "PIC16 Cooper [experimental]."); // Force static initialization. extern "C" void LLVMInitializePIC16Target() { } // PIC16TargetMachine - Traditional PIC16 Machine. -PIC16TargetMachine::PIC16TargetMachine(const Target &T, const Module &M, - const std::string &FS, bool Cooper) -: LLVMTargetMachine(T), - Subtarget(M, FS, Cooper), +PIC16TargetMachine::PIC16TargetMachine(const Module &M, const std::string &FS, + bool Cooper) +: 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 Target &T, const Module &M, - const std::string &FS) - : PIC16TargetMachine(T, M, FS, true) {} +CooperTargetMachine::CooperTargetMachine(const Module &M, const std::string &FS) + : PIC16TargetMachine(M, FS, true) {} const TargetAsmInfo *PIC16TargetMachine::createTargetAsmInfo() const { diff --git a/llvm/lib/Target/PIC16/PIC16TargetMachine.h b/llvm/lib/Target/PIC16/PIC16TargetMachine.h index f14d8fd28f8..a0080df6c5f 100644 --- a/llvm/lib/Target/PIC16/PIC16TargetMachine.h +++ b/llvm/lib/Target/PIC16/PIC16TargetMachine.h @@ -41,7 +41,7 @@ protected: virtual const TargetAsmInfo *createTargetAsmInfo() const; public: - PIC16TargetMachine(const Target &T, const Module &M, const std::string &FS, + PIC16TargetMachine(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 Target &T, const Module &M, const std::string &FS); + CooperTargetMachine(const Module &M, const std::string &FS); }; // CooperTargetMachine. } // end namespace llvm diff --git a/llvm/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp b/llvm/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp index f568bc1b03c..7489e49ca58 100644 --- a/llvm/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp +++ b/llvm/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp @@ -43,7 +43,6 @@ #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" @@ -318,7 +317,7 @@ namespace { /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux class VISIBILITY_HIDDEN PPCLinuxAsmPrinter : public PPCAsmPrinter { public: - explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, + explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, PPCTargetMachine &TM, const TargetAsmInfo *T, bool V) : PPCAsmPrinter(O, TM, T, V){} @@ -344,7 +343,7 @@ namespace { class VISIBILITY_HIDDEN PPCDarwinAsmPrinter : public PPCAsmPrinter { formatted_raw_ostream &OS; public: - explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, + explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, PPCTargetMachine &TM, const TargetAsmInfo *T, bool V) : PPCAsmPrinter(O, TM, T, V), OS(O) {} @@ -1081,7 +1080,7 @@ bool PPCDarwinAsmPrinter::doFinalization(Module &M) { /// Darwin assembler can deal with. /// FunctionPass *llvm::createPPCAsmPrinterPass(formatted_raw_ostream &o, - TargetMachine &tm, + PPCTargetMachine &tm, bool verbose) { const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>(); @@ -1104,10 +1103,4 @@ extern "C" int PowerPCAsmPrinterForceLink; int PowerPCAsmPrinterForceLink = 0; // Force static initialization. -extern "C" void LLVMInitializePowerPCAsmPrinter() { - extern Target ThePPC32Target; - TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass); - - extern Target ThePPC64Target; - TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass); -} +extern "C" void LLVMInitializePowerPCAsmPrinter() { } diff --git a/llvm/lib/Target/PowerPC/PPC.h b/llvm/lib/Target/PowerPC/PPC.h index 3aa313c73aa..89dc1c131e7 100644 --- a/llvm/lib/Target/PowerPC/PPC.h +++ b/llvm/lib/Target/PowerPC/PPC.h @@ -30,7 +30,7 @@ namespace llvm { FunctionPass *createPPCBranchSelectionPass(); FunctionPass *createPPCISelDag(PPCTargetMachine &TM); FunctionPass *createPPCAsmPrinterPass(formatted_raw_ostream &OS, - TargetMachine &TM, + PPCTargetMachine &TM, bool Verbose); FunctionPass *createPPCCodeEmitterPass(PPCTargetMachine &TM, MachineCodeEmitter &MCE); diff --git a/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp b/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp index 7e401c453f0..c261f8793ff 100644 --- a/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp +++ b/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp @@ -30,13 +30,10 @@ extern "C" int PowerPCTargetMachineModule; int PowerPCTargetMachineModule = 0; // Register the targets -extern Target ThePPC32Target; static RegisterTarget<PPC32TargetMachine> -X(ThePPC32Target, "ppc32", "PowerPC 32"); - -extern Target ThePPC64Target; +X("ppc32", "PowerPC 32"); static RegisterTarget<PPC64TargetMachine> -Y(ThePPC64Target, "ppc64", "PowerPC 64"); +Y("ppc64", "PowerPC 64"); // Force static initialization. extern "C" void LLVMInitializePowerPCTarget() { } @@ -51,10 +48,60 @@ const TargetAsmInfo *PPCTargetMachine::createTargetAsmInfo() const { return new PPCLinuxTargetAsmInfo(*this); } -PPCTargetMachine::PPCTargetMachine(const Target&T, const Module &M, - const std::string &FS, bool is64Bit) - : LLVMTargetMachine(T), - Subtarget(*this, M, FS, is64Bit), +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), DataLayout(Subtarget.getTargetDataString()), InstrInfo(*this), FrameInfo(*this, is64Bit), JITInfo(*this, is64Bit), TLInfo(*this), InstrItins(Subtarget.getInstrItineraryData()), MachOWriterInfo(*this) { @@ -71,15 +118,13 @@ PPCTargetMachine::PPCTargetMachine(const Target&T, const Module &M, /// groups, which typically degrades performance. bool PPCTargetMachine::getEnableTailMergeDefault() const { return false; } -PPC32TargetMachine::PPC32TargetMachine(const Target &T, const Module &M, - const std::string &FS) - : PPCTargetMachine(T, M, FS, false) { +PPC32TargetMachine::PPC32TargetMachine(const Module &M, const std::string &FS) + : PPCTargetMachine(M, FS, false) { } -PPC64TargetMachine::PPC64TargetMachine(const Target &T, const Module &M, - const std::string &FS) - : PPCTargetMachine(T, M, FS, true) { +PPC64TargetMachine::PPC64TargetMachine(const Module &M, const std::string &FS) + : PPCTargetMachine(M, FS, true) { } diff --git a/llvm/lib/Target/PowerPC/PPCTargetMachine.h b/llvm/lib/Target/PowerPC/PPCTargetMachine.h index 794123ad164..e6f61029f3b 100644 --- a/llvm/lib/Target/PowerPC/PPCTargetMachine.h +++ b/llvm/lib/Target/PowerPC/PPCTargetMachine.h @@ -45,13 +45,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, - TargetMachine &m, + PPCTargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - PPCTargetMachine(const Target &T, const Module &M, const std::string &FS, - bool is64Bit); + PPCTargetMachine(const Module &M, const std::string &FS, bool is64Bit); virtual const PPCInstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const PPCFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -104,14 +103,20 @@ public: /// class PPC32TargetMachine : public PPCTargetMachine { public: - PPC32TargetMachine(const Target &T, const Module &M, const std::string &FS); + PPC32TargetMachine(const Module &M, const std::string &FS); + + static unsigned getJITMatchQuality(); + static unsigned getModuleMatchQuality(const Module &M); }; /// PPC64TargetMachine - PowerPC 64-bit target machine. /// class PPC64TargetMachine : public PPCTargetMachine { public: - PPC64TargetMachine(const Target &T, const Module &M, const std::string &FS); + PPC64TargetMachine(const Module &M, const std::string &FS); + + static unsigned getJITMatchQuality(); + static unsigned getModuleMatchQuality(const Module &M); }; } // end namespace llvm diff --git a/llvm/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp b/llvm/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp index 03735b0f41d..c580285e35f 100644 --- a/llvm/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp +++ b/llvm/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp @@ -26,7 +26,6 @@ #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" @@ -360,8 +359,4 @@ namespace { } // Force static initialization. -extern "C" void LLVMInitializeSparcAsmPrinter() { - extern Target TheSparcTarget; - TargetRegistry::RegisterAsmPrinter(TheSparcTarget, - createSparcCodePrinterPass); -} +extern "C" void LLVMInitializeSparcAsmPrinter() { } diff --git a/llvm/lib/Target/Sparc/SparcTargetMachine.cpp b/llvm/lib/Target/Sparc/SparcTargetMachine.cpp index 25503631134..66d549797dc 100644 --- a/llvm/lib/Target/Sparc/SparcTargetMachine.cpp +++ b/llvm/lib/Target/Sparc/SparcTargetMachine.cpp @@ -19,8 +19,7 @@ using namespace llvm; // Register the target. -extern Target TheSparcTarget; -static RegisterTarget<SparcTargetMachine> X(TheSparcTarget, "sparc", "SPARC"); +static RegisterTarget<SparcTargetMachine> X("sparc", "SPARC"); // No assembler printer by default SparcTargetMachine::AsmPrinterCtorFn SparcTargetMachine::AsmPrinterCtor = 0; @@ -36,14 +35,38 @@ const TargetAsmInfo *SparcTargetMachine::createTargetAsmInfo() const { /// SparcTargetMachine ctor - Create an ILP32 architecture model /// -SparcTargetMachine::SparcTargetMachine(const Target &T, const Module &M, - const std::string &FS) - : LLVMTargetMachine(T), - DataLayout("E-p:32:32-f128:128:128"), +SparcTargetMachine::SparcTargetMachine(const Module &M, const std::string &FS) + : 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/llvm/lib/Target/Sparc/SparcTargetMachine.h b/llvm/lib/Target/Sparc/SparcTargetMachine.h index ca34b96365d..5da4a7839d4 100644 --- a/llvm/lib/Target/Sparc/SparcTargetMachine.h +++ b/llvm/lib/Target/Sparc/SparcTargetMachine.h @@ -43,7 +43,7 @@ protected: static AsmPrinterCtorFn AsmPrinterCtor; public: - SparcTargetMachine(const Target &T, const Module &M, const std::string &FS); + SparcTargetMachine(const Module &M, const std::string &FS); virtual const SparcInstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -55,6 +55,7 @@ public: return const_cast<SparcTargetLowering*>(&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/llvm/lib/Target/TargetMachine.cpp b/llvm/lib/Target/TargetMachine.cpp index fb95c52a999..c487cb80530 100644 --- a/llvm/lib/Target/TargetMachine.cpp +++ b/llvm/lib/Target/TargetMachine.cpp @@ -176,8 +176,8 @@ EnableStrongPHIElim(cl::Hidden, "strong-phi-elim", // TargetMachine Class // -TargetMachine::TargetMachine(const Target &T) - : TheTarget(T), AsmInfo(0) { +TargetMachine::TargetMachine() + : AsmInfo(0) { // Typically it will be subtargets that will adjust FloatABIType from Default // to Soft or Hard. if (UseSoftFloat) diff --git a/llvm/lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h b/llvm/lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h index b8a25a6bedf..9721fdcd4b9 100644 --- a/llvm/lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h +++ b/llvm/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, TargetMachine &TM, + explicit X86ATTAsmPrinter(formatted_raw_ostream &O, X86TargetMachine &TM, const TargetAsmInfo *T, bool V) : AsmPrinter(O, TM, T, V) { Subtarget = &TM.getSubtarget<X86Subtarget>(); diff --git a/llvm/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp b/llvm/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp index 3fad77e8ca6..40b24f338fa 100644 --- a/llvm/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp +++ b/llvm/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp @@ -17,7 +17,6 @@ #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 @@ -25,7 +24,7 @@ using namespace llvm; /// machine description. /// FunctionPass *llvm::createX86CodePrinterPass(formatted_raw_ostream &o, - TargetMachine &tm, + X86TargetMachine &tm, bool verbose) { const X86Subtarget *Subtarget = &tm.getSubtarget<X86Subtarget>(); @@ -46,10 +45,4 @@ extern "C" int X86AsmPrinterForceLink; int X86AsmPrinterForceLink = 0; // Force static initialization. -extern "C" void LLVMInitializeX86AsmPrinter() { - extern Target TheX86_32Target; - TargetRegistry::RegisterAsmPrinter(TheX86_32Target, createX86CodePrinterPass); - - extern Target TheX86_64Target; - TargetRegistry::RegisterAsmPrinter(TheX86_64Target, createX86CodePrinterPass); -} +extern "C" void LLVMInitializeX86AsmPrinter() { } diff --git a/llvm/lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h b/llvm/lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h index 603de3e3736..8872869187a 100644 --- a/llvm/lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h +++ b/llvm/lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h @@ -25,7 +25,7 @@ namespace llvm { struct VISIBILITY_HIDDEN X86IntelAsmPrinter : public AsmPrinter { - explicit X86IntelAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, + explicit X86IntelAsmPrinter(formatted_raw_ostream &O, X86TargetMachine &TM, const TargetAsmInfo *T, bool V) : AsmPrinter(O, TM, T, V) {} diff --git a/llvm/lib/Target/X86/X86.h b/llvm/lib/Target/X86/X86.h index 457e18ab0f3..ead4ce1f3f8 100644 --- a/llvm/lib/Target/X86/X86.h +++ b/llvm/lib/Target/X86/X86.h @@ -47,7 +47,7 @@ FunctionPass *createX87FPRegKillInserterPass(); /// using the given target machine description. /// FunctionPass *createX86CodePrinterPass(formatted_raw_ostream &o, - TargetMachine &tm, + X86TargetMachine &tm, bool Verbose); /// createX86CodeEmitterPass - Return a pass that emits the collected X86 code diff --git a/llvm/lib/Target/X86/X86TargetMachine.cpp b/llvm/lib/Target/X86/X86TargetMachine.cpp index c64084756c1..40dc18df34b 100644 --- a/llvm/lib/Target/X86/X86TargetMachine.cpp +++ b/llvm/lib/Target/X86/X86TargetMachine.cpp @@ -31,18 +31,13 @@ extern "C" int X86TargetMachineModule; int X86TargetMachineModule = 0; // Register the target. -extern Target TheX86_32Target; static RegisterTarget<X86_32TargetMachine> -X(TheX86_32Target, "x86", "32-bit X86: Pentium-Pro and above"); - -extern Target TheX86_64Target; +X("x86", "32-bit X86: Pentium-Pro and above"); static RegisterTarget<X86_64TargetMachine> -Y(TheX86_64Target, "x86-64", "64-bit X86: EM64T and AMD64"); +Y("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; @@ -66,23 +61,78 @@ const TargetAsmInfo *X86TargetMachine::createTargetAsmInfo() const { } } -X86_32TargetMachine::X86_32TargetMachine(const Target &T, const Module &M, - const std::string &FS) - : X86TargetMachine(T, M, FS, false) { +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_64TargetMachine::X86_64TargetMachine(const Target &T, const Module &M, - const std::string &FS) - : X86TargetMachine(T, M, FS, true) { +X86_64TargetMachine::X86_64TargetMachine(const Module &M, const std::string &FS) + : X86TargetMachine(M, FS, true) { } /// X86TargetMachine ctor - Create an X86 target. /// -X86TargetMachine::X86TargetMachine(const Target &T, const Module &M, - const std::string &FS, bool is64Bit) - : LLVMTargetMachine(T), - Subtarget(M, FS, is64Bit), +X86TargetMachine::X86TargetMachine(const Module &M, const std::string &FS, + bool is64Bit) + : Subtarget(M, FS, is64Bit), DataLayout(Subtarget.getDataLayout()), FrameInfo(TargetFrameInfo::StackGrowsDown, Subtarget.getStackAlignment(), Subtarget.is64Bit() ? -8 : -4), diff --git a/llvm/lib/Target/X86/X86TargetMachine.h b/llvm/lib/Target/X86/X86TargetMachine.h index da6811bd236..ea7a453a1ad 100644 --- a/llvm/lib/Target/X86/X86TargetMachine.h +++ b/llvm/lib/Target/X86/X86TargetMachine.h @@ -44,13 +44,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, - TargetMachine &tm, + X86TargetMachine &tm, bool verbose); static AsmPrinterCtorFn AsmPrinterCtor; public: - X86TargetMachine(const Target &T, const Module &M, const std::string &FS, - bool is64Bit); + X86TargetMachine(const Module &M, const std::string &FS, bool is64Bit); virtual const X86InstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -67,6 +66,9 @@ public: return Subtarget.isTargetELF() ? &ELFWriterInfo : 0; } + static unsigned getModuleMatchQuality(const Module &M); + static unsigned getJITMatchQuality(); + static void registerAsmPrinter(AsmPrinterCtorFn F) { AsmPrinterCtor = F; } @@ -99,7 +101,7 @@ public: /// class X86_32TargetMachine : public X86TargetMachine { public: - X86_32TargetMachine(const Target &T, const Module &M, const std::string &FS); + X86_32TargetMachine(const Module &M, const std::string &FS); static unsigned getJITMatchQuality(); static unsigned getModuleMatchQuality(const Module &M); @@ -109,7 +111,7 @@ public: /// class X86_64TargetMachine : public X86TargetMachine { public: - X86_64TargetMachine(const Target &T, const Module &M, const std::string &FS); + X86_64TargetMachine(const Module &M, const std::string &FS); static unsigned getJITMatchQuality(); static unsigned getModuleMatchQuality(const Module &M); diff --git a/llvm/lib/Target/XCore/XCoreTargetMachine.cpp b/llvm/lib/Target/XCore/XCoreTargetMachine.cpp index 7fc869495a9..42b98753ecf 100644 --- a/llvm/lib/Target/XCore/XCoreTargetMachine.cpp +++ b/llvm/lib/Target/XCore/XCoreTargetMachine.cpp @@ -26,10 +26,9 @@ using namespace llvm; extern "C" int XCoreTargetMachineModule; int XCoreTargetMachineModule = 0; -extern Target TheXCoreTarget; namespace { // Register the target. - RegisterTarget<XCoreTargetMachine> X(TheXCoreTarget, "xcore", "XCore"); + RegisterTarget<XCoreTargetMachine> X("xcore", "XCore"); } // Force static initialization. @@ -41,10 +40,8 @@ const TargetAsmInfo *XCoreTargetMachine::createTargetAsmInfo() const { /// XCoreTargetMachine ctor - Create an ILP32 architecture model /// -XCoreTargetMachine::XCoreTargetMachine(const Target &T, const Module &M, - const std::string &FS) - : LLVMTargetMachine(T), - Subtarget(*this, M, FS), +XCoreTargetMachine::XCoreTargetMachine(const Module &M, const std::string &FS) + : 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(), @@ -52,6 +49,15 @@ XCoreTargetMachine::XCoreTargetMachine(const Target &T, const Module &M, 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/llvm/lib/Target/XCore/XCoreTargetMachine.h b/llvm/lib/Target/XCore/XCoreTargetMachine.h index e88c81b9bbd..081cf7a2a5a 100644 --- a/llvm/lib/Target/XCore/XCoreTargetMachine.h +++ b/llvm/lib/Target/XCore/XCoreTargetMachine.h @@ -36,7 +36,7 @@ protected: virtual const TargetAsmInfo *createTargetAsmInfo() const; public: - XCoreTargetMachine(const Target &T, const Module &M, const std::string &FS); + XCoreTargetMachine(const Module &M, const std::string &FS); virtual const XCoreInstrInfo *getInstrInfo() const { return &InstrInfo; } virtual const XCoreFrameInfo *getFrameInfo() const { return &FrameInfo; } @@ -49,6 +49,7 @@ 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/llvm/tools/llc/llc.cpp b/llvm/tools/llc/llc.cpp index 346e54706d2..9acfcd29000 100644 --- a/llvm/tools/llc/llc.cpp +++ b/llvm/tools/llc/llc.cpp @@ -128,8 +128,7 @@ GetFileNameRoot(const std::string &InputFilename) { return outputFilename; } -static formatted_raw_ostream *GetOutputStream(const char *TargetName, - const char *ProgName) { +static formatted_raw_ostream *GetOutputStream(const char *ProgName) { if (OutputFilename != "") { if (OutputFilename == "-") return &fouts(); @@ -170,10 +169,10 @@ static formatted_raw_ostream *GetOutputStream(const char *TargetName, bool Binary = false; switch (FileType) { case TargetMachine::AssemblyFile: - if (TargetName[0] == 'c') { - if (TargetName[1] == 0) + if (MArch->Name[0] == 'c') { + if (MArch->Name[1] == 0) OutputFilename += ".cbe.c"; - else if (TargetName[1] == 'p' && TargetName[2] == 'p') + else if (MArch->Name[1] == 'p' && MArch->Name[2] == 'p') OutputFilename += ".cpp"; else OutputFilename += ".s"; @@ -249,13 +248,10 @@ int main(int argc, char **argv) { // Allocate target machine. First, check whether the user has // explicitly specified an architecture to compile for. - const Target *TheTarget; - if (MArch) { - TheTarget = &MArch->TheTarget; - } else { + if (MArch == 0) { std::string Err; - TheTarget = TargetRegistry::getClosestStaticTargetForModule(mod, Err); - if (TheTarget == 0) { + MArch = TargetMachineRegistry::getClosestStaticTargetForModule(mod, Err); + if (MArch == 0) { errs() << argv[0] << ": error auto-selecting target for module '" << Err << "'. Please use the -march option to explicitly " << "pick a target.\n"; @@ -273,13 +269,12 @@ int main(int argc, char **argv) { FeaturesStr = Features.getString(); } - std::auto_ptr<TargetMachine> - target(TheTarget->createTargetMachine(mod, FeaturesStr)); + std::auto_ptr<TargetMachine> target(MArch->CtorFn(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(TheTarget->getName(), argv[0]); + formatted_raw_ostream *Out = GetOutputStream(argv[0]); if (Out == 0) return 1; CodeGenOpt::Level OLvl = CodeGenOpt::Default; diff --git a/llvm/tools/lto/LTOCodeGenerator.cpp b/llvm/tools/lto/LTOCodeGenerator.cpp index cb6c4ae6f5b..b4c4e7767b9 100644 --- a/llvm/tools/lto/LTOCodeGenerator.cpp +++ b/llvm/tools/lto/LTOCodeGenerator.cpp @@ -328,9 +328,9 @@ bool LTOCodeGenerator::determineTarget(std::string& errMsg) if ( _target == NULL ) { // create target machine from info for merged modules Module* mergedModule = _linker.getModule(); - const Target *march = - TargetRegistry::getClosestStaticTargetForModule(*mergedModule, - errMsg); + const TargetMachineRegistry::entry* march = + TargetMachineRegistry::getClosestStaticTargetForModule( + *mergedModule, errMsg); if ( march == NULL ) return true; @@ -351,7 +351,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->createTargetMachine(*mergedModule, FeatureStr.c_str()); + _target = march->CtorFn(*mergedModule, FeatureStr.c_str()); } return false; } diff --git a/llvm/tools/lto/LTOModule.cpp b/llvm/tools/lto/LTOModule.cpp index be6543c8f7f..38ee1cc7a28 100644 --- a/llvm/tools/lto/LTOModule.cpp +++ b/llvm/tools/lto/LTOModule.cpp @@ -147,15 +147,15 @@ LTOModule* LTOModule::makeLTOModule(MemoryBuffer* buffer, if ( !m ) return NULL; // find machine architecture for this module - const Target* march = - TargetRegistry::getClosestStaticTargetForModule(*m, errMsg); + const TargetMachineRegistry::entry* march = + TargetMachineRegistry::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->createTargetMachine(*m, FeatureStr); + TargetMachine* target = march->CtorFn(*m, FeatureStr); return new LTOModule(m.take(), target); } |
