RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 02:52:53 +02:00
Code Issues Projects Releases Wiki Activity

Reapply TargetRegistry refactoring commits.

Browse Source 
--- 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

llvm-svn: 75820
This commit is contained in:
Daniel Dunbar 2009-07-15 20:24:03 +00:00
parent 2c9049f5bf
commit 5707dd7f73
54 changed files with 312 additions and 638 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
include/llvm/Target/TargetMachine.h
View File

@ -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.

47
include/llvm/Target/TargetMachineRegistry.h
View File

@ -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<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 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<class TargetMachineImpl>
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);
}
};

16
include/llvm/Target/TargetRegistry.h
View File

@ -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

4
include/llvm/Target/TargetSelect.h
View File

@ -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;

22
lib/ExecutionEngine/JIT/TargetSelect.cpp
View File

@ -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.

12
lib/Support/TargetRegistry.cpp
View File

@ -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;

2
lib/Target/ARM/ARM.h
View File

@ -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);

78
lib/Target/ARM/ARMTargetMachine.cpp
View File

@ -36,8 +36,11 @@ extern "C" int ARMTargetMachineModule;
int ARMTargetMachineModule = 0;
// Register the target.
static RegisterTarget<ARMTargetMachine> X("arm", "ARM");
static RegisterTarget<ThumbTargetMachine> Y("thumb", "Thumb");
extern Target TheARMTarget;
static RegisterTarget<ARMTargetMachine> X(TheARMTarget, "arm", "ARM");
extern Target TheThumbTarget;
static RegisterTarget<ThumbTargetMachine> 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) {

12
lib/Target/ARM/ARMTargetMachine.h
View File

@ -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 {

9
lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp
View File

@ -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);
}

37
lib/Target/Alpha/AlphaTargetMachine.cpp
View File

@ -22,7 +22,9 @@
using namespace llvm;
// Register the targets
static RegisterTarget<AlphaTargetMachine> X("alpha", "Alpha [experimental]");
extern Target TheAlphaTarget;
static RegisterTarget<AlphaTargetMachine> 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),

5
lib/Target/Alpha/AlphaTargetMachine.h
View File

@ -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);

11
lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp
View File

@ -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);
}

22
lib/Target/CBackend/CBackend.cpp
View File

@ -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<CTargetMachine> X("c", "C backend");
extern Target TheCBackendTarget;
static RegisterTarget<CTargetMachine> 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];
}

8
lib/Target/CBackend/CTargetMachine.h
View File

@ -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; }
};

14
lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp
View File

@ -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 <set>
@ -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);
}

2
lib/Target/CellSPU/SPU.h
View File

@ -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: --==*/

23
lib/Target/CellSPU/SPUTargetMachine.cpp
View File

@ -23,10 +23,11 @@
using namespace llvm;
extern Target TheCellSPUTarget;
namespace {
// Register the targets
RegisterTarget<SPUTargetMachine>
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),

10
lib/Target/CellSPU/SPUTargetMachine.h
View File

@ -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<SPUTargetLowering*>(&TLInfo);

3
lib/Target/CppBackend/CPPBackend.cpp
View File

@ -81,7 +81,8 @@ extern "C" int CppBackendTargetMachineModule;
int CppBackendTargetMachineModule = 0;
// Register the target.
static RegisterTarget<CPPTargetMachine> X("cpp", "C++ backend");
extern Target TheCppBackendTarget;
static RegisterTarget<CPPTargetMachine> X(TheCppBackendTarget, "cpp", "C++ backend");
// Force static initialization.
extern "C" void LLVMInitializeCppBackendTarget() { }

7
lib/Target/CppBackend/CPPTargetMachine.h
View File

@ -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; }
};

8
lib/Target/IA64/AsmPrinter/IA64AsmPrinter.cpp
View File

@ -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);
}

2
lib/Target/IA64/IA64.h
View File

@ -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

35
lib/Target/IA64/IA64TargetMachine.cpp
View File

@ -20,7 +20,8 @@
using namespace llvm;
// Register the target
static RegisterTarget<IA64TargetMachine> X("ia64",
extern Target TheIA64Target;
static RegisterTarget<IA64TargetMachine> 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
}

6
lib/Target/IA64/IA64TargetMachine.h
View File

@ -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);

7
lib/Target/MSIL/MSILWriter.cpp
View File

@ -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<MSILTarget> X("msil", "MSIL backend");
extern Target TheMSILTarget;
static RegisterTarget<MSILTarget> X(TheMSILTarget, "msil", "MSIL backend");
// Force static initialization.
extern "C" void LLVMInitializeMSILTarget() { }

18
lib/Target/MSP430/MSP430TargetMachine.cpp
View File

@ -32,14 +32,17 @@ int MSP430TargetMachineModule = 0;
// Register the targets
extern Target TheMSP430Target;
static RegisterTarget<MSP430TargetMachine>
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;
}

3
lib/Target/MSP430/MSP430TargetMachine.h
View File

@ -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

14
lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp
View File

@ -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<MipsSubtarget>();
@ -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);
}

2
lib/Target/Mips/Mips.h
View File

@ -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;

51
lib/Target/Mips/MipsTargetMachine.cpp
View File

@ -28,8 +28,12 @@ extern "C" int MipsTargetMachineModule;
int MipsTargetMachineModule = 0;
// Register the target.
static RegisterTarget<MipsTargetMachine> X("mips", "Mips");
static RegisterTarget<MipselTargetMachine> Y("mipsel", "Mipsel");
extern Target TheMipsTarget;
static RegisterTarget<MipsTargetMachine> X(TheMipsTarget, "mips", "Mips");
extern Target TheMipselTarget;
static RegisterTarget<MipselTargetMachine> 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.

9
lib/Target/Mips/MipsTargetMachine.h
View File

@ -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<MipsTargetLowering*>(&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);
};

19
lib/Target/PIC16/PIC16TargetMachine.cpp
View File

@ -32,26 +32,31 @@ int PIC16TargetMachineModule = 0;
// Register the targets
extern Target ThePIC16Target;
static RegisterTarget<PIC16TargetMachine>
X("pic16", "PIC16 14-bit [experimental].");
X(ThePIC16Target, "pic16", "PIC16 14-bit [experimental].");
extern Target TheCooperTarget;
static RegisterTarget<CooperTargetMachine>
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 {

4
lib/Target/PIC16/PIC16TargetMachine.h
View File

@ -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

15
lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp
View File

@ -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<PPCSubtarget>();
@ -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);
}

2
lib/Target/PowerPC/PPC.h
View File

@ -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);

75
lib/Target/PowerPC/PPCTargetMachine.cpp
View File

@ -30,10 +30,13 @@ extern "C" int PowerPCTargetMachineModule;
int PowerPCTargetMachineModule = 0;
// Register the targets
extern Target ThePPC32Target;
static RegisterTarget<PPC32TargetMachine>
X("ppc32", "PowerPC 32");
X(ThePPC32Target, "ppc32", "PowerPC 32");
extern Target ThePPC64Target;
static RegisterTarget<PPC64TargetMachine>
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) {
}

15
lib/Target/PowerPC/PPCTargetMachine.h
View File

@ -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

7
lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp
View File

@ -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);
}

35
lib/Target/Sparc/SparcTargetMachine.cpp
View File

@ -19,7 +19,8 @@
using namespace llvm;
// Register the target.
static RegisterTarget<SparcTargetMachine> X("sparc", "SPARC");
extern Target TheSparcTarget;
static RegisterTarget<SparcTargetMachine> 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));

3
lib/Target/Sparc/SparcTargetMachine.h
View File

@ -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<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);

4
lib/Target/TargetMachine.cpp
View File

@ -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)

78
lib/Target/TargetMachineRegistry.cpp
View File

@ -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 <algorithm>
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<std::pair<unsigned, const entry *> > UsableTargets;
for (Registry<TargetMachine>::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<std::pair<unsigned, const entry *> > UsableTargets;
for (Registry<TargetMachine>::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;
}

2
lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h
View File

@ -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<X86Subtarget>();

11
lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp
View File

@ -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<X86Subtarget>();
@ -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);
}

2
lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h
View File

@ -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) {}

2
lib/Target/X86/X86.h
View File

@ -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

86
lib/Target/X86/X86TargetMachine.cpp
View File

@ -31,13 +31,18 @@ extern "C" int X86TargetMachineModule;
int X86TargetMachineModule = 0;
// Register the target.
extern Target TheX86_32Target;
static RegisterTarget<X86_32TargetMachine>
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<X86_64TargetMachine>
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),

12
lib/Target/X86/X86TargetMachine.h
View File

@ -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);

18
lib/Target/XCore/XCoreTargetMachine.cpp
View File

@ -26,9 +26,10 @@ using namespace llvm;
extern "C" int XCoreTargetMachineModule;
int XCoreTargetMachineModule = 0;
extern Target TheXCoreTarget;
namespace {
// Register the target.
RegisterTarget<XCoreTargetMachine> X("xcore", "XCore");
RegisterTarget<XCoreTargetMachine> 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));

3
lib/Target/XCore/XCoreTargetMachine.h
View File

@ -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);

23
tools/llc/llc.cpp
View File

@ -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<TargetMachine> target(MArch->CtorFn(mod, FeaturesStr));
std::auto_ptr<TargetMachine>
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;

8
tools/lto/LTOCodeGenerator.cpp
View File

@ -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;
}

6
tools/lto/LTOModule.cpp
View File

@ -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);
}