namespace llvm {
+class Target;
class TargetAsmInfo;
class TargetData;
class TargetSubtarget;
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.
///
/// 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
// -- Pipelines and scheduling information
///
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.
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);
}
};
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 &,
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.
/// 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") :
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; }
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();
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 {
#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),
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; }
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,
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),
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 {
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,
/// 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
}
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; }
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,
// 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"),
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; }
// 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")),
}
MipselTargetMachine::
-MipselTargetMachine(const Module &M, const std::string &FS) :
- MipsTargetMachine(M, FS, true) {}
+MipselTargetMachine(const Target &T, const Module &M, const std::string &FS) :
+ MipsTargetMachine(T, M, FS, true) {}
// return 0 and must specify -march to gen MIPS code.
unsigned MipsTargetMachine::
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;
///
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);
};
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 {
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; }
/// 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
}
-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) {
/// 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) {
}
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; }
///
class PPC32TargetMachine : public PPCTargetMachine {
public:
- PPC32TargetMachine(const Module &M, const std::string &FS);
+ PPC32TargetMachine(const Target &T, const Module &M, const std::string &FS);
static unsigned getJITMatchQuality();
static unsigned getModuleMatchQuality(const Module &M);
///
class PPC64TargetMachine : public PPCTargetMachine {
public:
- PPC64TargetMachine(const Module &M, const std::string &FS);
+ PPC64TargetMachine(const Target &T, const Module &M, const std::string &FS);
static unsigned getJITMatchQuality();
static unsigned getModuleMatchQuality(const Module &M);
/// 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) {
}
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; }
// 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)
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),
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; }
///
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);
///
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);
/// 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(),
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; }