maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

1. Use SubtargetFeatures in llc/lli. 

2. Propagate feature "string" to all targets.

3. Implement use of SubtargetFeatures in PowerPCTargetSubtarget.

llvm-svn: 23192
This commit is contained in:
Jim Laskey 2005-09-01 21:38:21 +00:00
parent 3fee6a51a9
commit 19058c3989
25 changed files with 188 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
llvm/Xcode/LLVM.xcodeproj/project.pbxproj
View File

@ -33,6 +33,8 @@
/* End PBXBuildStyle section */
/* Begin PBXFileReference section */
CF9BCD0808C74DE0001E7011 /* SubtargetFeature.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SubtargetFeature.h; sourceTree = "<group>"; };
CF9BCD1508C75070001E7011 /* SubtargetFeature.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SubtargetFeature.cpp; sourceTree = "<group>"; };
DE66EC5B08ABE86900323D32 /* AsmWriter.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = AsmWriter.cpp; path = ../lib/VMCore/AsmWriter.cpp; sourceTree = SOURCE_ROOT; };
DE66EC5C08ABE86A00323D32 /* BasicBlock.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = BasicBlock.cpp; path = ../lib/VMCore/BasicBlock.cpp; sourceTree = SOURCE_ROOT; };
DE66EC5D08ABE86A00323D32 /* ConstantFolding.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = ConstantFolding.cpp; path = ../lib/VMCore/ConstantFolding.cpp; sourceTree = SOURCE_ROOT; };
@ -1249,6 +1251,7 @@
DE66EFC908ABEE5F00323D32 /* SparcV9 */,
DE66F09308ABEE6000323D32 /* X86 */,
DE66EF1008ABEE5E00323D32 /* MRegisterInfo.cpp */,
CF9BCD1508C75070001E7011 /* SubtargetFeature.cpp */,
DE66F08A08ABEE6000323D32 /* Target.td */,
DE66F08B08ABEE6000323D32 /* TargetData.cpp */,
DE66F08C08ABEE6000323D32 /* TargetFrameInfo.cpp */,
@ -1958,6 +1961,7 @@
isa = PBXGroup;
children = (
DE66F2A008ABF03200323D32 /* MRegisterInfo.h */,
CF9BCD0808C74DE0001E7011 /* SubtargetFeature.h */,
DE66F2A108ABF03200323D32 /* TargetData.h */,
DE66F2A208ABF03200323D32 /* TargetFrameInfo.h */,
DE66F2A308ABF03200323D32 /* TargetInstrInfo.h */,
@ -2218,7 +2222,7 @@
PRODUCT_NAME = LLVM;
};
buildToolPath = /usr/bin/make;
buildWorkingDirectory = /llvm/obj;
buildWorkingDirectory = /llvm/obj/;
dependencies = (
);
name = LLVM;

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

@ -49,7 +49,8 @@ namespace llvm {
struct Entry {
const char *Name;
const char *ShortDesc;
TargetMachine *(*CtorFn)(const Module &, IntrinsicLowering*);
TargetMachine *(*CtorFn)(const Module &, IntrinsicLowering*,
const std::string &);
unsigned (*ModuleMatchQualityFn)(const Module &M);
unsigned (*JITMatchQualityFn)();
@ -57,7 +58,8 @@ namespace llvm {
protected:
Entry(const char *N, const char *SD,
TargetMachine *(*CF)(const Module &, IntrinsicLowering*),
TargetMachine *(*CF)(const Module &, IntrinsicLowering*,
const std::string &),
unsigned (*MMF)(const Module &M), unsigned (*JMF)());
private:
const Entry *Next; // Next entry in the linked list.
@ -80,8 +82,9 @@ namespace llvm {
&TargetMachineImpl::getJITMatchQuality) {
}
private:
static TargetMachine *Allocator(const Module &M, IntrinsicLowering *IL) {
return new TargetMachineImpl(M, IL);
static TargetMachine *Allocator(const Module &M, IntrinsicLowering *IL,
const std::string &FS) {
return new TargetMachineImpl(M, IL, FS);
}
};

25
llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp
View File

@ -15,6 +15,7 @@
#include "JIT.h"
#include "llvm/Module.h"
#include "llvm/ModuleProvider.h"
#include "llvm/Target/SubtargetFeature.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachineRegistry.h"
#include <iostream>
@ -23,6 +24,18 @@ using namespace llvm;
static cl::opt<const TargetMachineRegistry::Entry*, false, TargetNameParser>
MArch("march", cl::desc("Architecture to generate assembly for:"));
static cl::opt<std::string>
MCPU("mcpu",
cl::desc("Target a specific cpu type"),
cl::value_desc("cpu-name"),
cl::init(""));
static cl::list<std::string>
MAttrs("mattr",
cl::CommaSeparated,
cl::desc("Target specific attributes:"),
cl::value_desc("attributes"));
/// create - Create an return a new JIT compiler if there is one available
/// for the current target. Otherwise, return null.
///
@ -37,8 +50,18 @@ ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
<< "-march switch.\n";
}
// Package up features to be passed to target/subtarget
std::string FeaturesStr;
if (MCPU.size() || MAttrs.size()) {
SubtargetFeatures Features;
Features.setCPU(MCPU);
for (unsigned i = 0; i != MAttrs.size(); ++i)
Features.AddFeature(MAttrs[i]);
FeaturesStr = Features.getString();
}
// Allocate a target...
TargetMachine *Target = MArch->CtorFn(*MP->getModule(), IL);
TargetMachine *Target = MArch->CtorFn(*MP->getModule(), IL, FeaturesStr);
assert(Target && "Could not allocate target machine!");
// If the target supports JIT code generation, return a new JIT now.

3
llvm/lib/Target/Alpha/AlphaTargetMachine.cpp
View File

@ -58,7 +58,8 @@ unsigned AlphaTargetMachine::getJITMatchQuality() {
#endif
}
AlphaTargetMachine::AlphaTargetMachine( const Module &M, IntrinsicLowering *IL)
AlphaTargetMachine::AlphaTargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS)
: TargetMachine("alpha", IL, true),
FrameInfo(TargetFrameInfo::StackGrowsDown, 16, 0),
JITInfo(*this)

3
llvm/lib/Target/Alpha/AlphaTargetMachine.h
View File

@ -31,7 +31,8 @@ class AlphaTargetMachine : public TargetMachine {
AlphaJITInfo JITInfo;
public:
AlphaTargetMachine(const Module &M, IntrinsicLowering *IL);
AlphaTargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS);
virtual const AlphaInstrInfo *getInstrInfo() const { return &InstrInfo; }
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }

3
llvm/lib/Target/CBackend/CTargetMachine.h
View File

@ -20,7 +20,8 @@ namespace llvm {
class IntrinsicLowering;
struct CTargetMachine : public TargetMachine {
CTargetMachine(const Module &M, IntrinsicLowering *IL) :
CTargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS) :
TargetMachine("CBackend", IL, M) {}
// This is the only thing that actually does anything here.

3
llvm/lib/Target/IA64/IA64TargetMachine.cpp
View File

@ -72,7 +72,8 @@ unsigned IA64TargetMachine::getModuleMatchQuality(const Module &M) {
/// IA64TargetMachine ctor - Create an LP64 architecture model
///
IA64TargetMachine::IA64TargetMachine(const Module &M, IntrinsicLowering *IL)
IA64TargetMachine::IA64TargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS)
: TargetMachine("IA64", IL, true),
FrameInfo(TargetFrameInfo::StackGrowsDown, 16, 0) { // FIXME? check this stuff
}

3
llvm/lib/Target/IA64/IA64TargetMachine.h
View File

@ -27,7 +27,8 @@ class IA64TargetMachine : public TargetMachine {
TargetFrameInfo FrameInfo;
//IA64JITInfo JITInfo;
public:
IA64TargetMachine(const Module &M, IntrinsicLowering *IL);
IA64TargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS);
virtual const IA64InstrInfo *getInstrInfo() const { return &InstrInfo; }
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }

3
llvm/lib/Target/PowerPC/PPC32TargetMachine.h
View File

@ -28,7 +28,8 @@ class PPC32TargetMachine : public PowerPCTargetMachine {
PPC32JITInfo JITInfo;
public:
PPC32TargetMachine(const Module &M, IntrinsicLowering *IL);
PPC32TargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS);
virtual const PPC32InstrInfo *getInstrInfo() const { return &InstrInfo; }
virtual const MRegisterInfo *getRegisterInfo() const {
return &InstrInfo.getRegisterInfo();

88
llvm/lib/Target/PowerPC/PPCSubtarget.cpp
View File

@ -15,6 +15,8 @@
#include "PowerPC.h"
#include "llvm/Module.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Target/SubtargetFeature.h"
using namespace llvm;
PPCTargetEnum llvm::PPCTarget = TargetDefault;
@ -30,13 +32,59 @@ namespace llvm {
cl::desc("Enable optimizations for GP cpus"));
}
enum PowerPCFeature {
PowerPCFeature64Bit = 1 << 0,
PowerPCFeatureAltivec = 1 << 1,
PowerPCFeatureFSqrt = 1 << 2,
PowerPCFeatureGPUL = 1 << 3,
};
/// Sorted (by key) array of values for CPU subtype.
static const SubtargetFeatureKV PowerPCSubTypeKV[] = {
{ "601" , 0 },
{ "602" , 0 },
{ "603" , 0 },
{ "603e" , 0 },
{ "603ev" , 0 },
{ "604" , 0 },
{ "604e" , 0 },
{ "620" , 0 },
{ "7400" , PowerPCFeatureAltivec },
{ "7450" , PowerPCFeatureAltivec },
{ "750" , 0 },
{ "970" , PowerPCFeature64Bit | PowerPCFeatureAltivec |
PowerPCFeatureFSqrt | PowerPCFeatureGPUL },
{ "g3" , 0 },
{ "g4" , PowerPCFeatureAltivec },
{ "g4+" , PowerPCFeatureAltivec },
{ "g5" , PowerPCFeature64Bit | PowerPCFeatureAltivec |
PowerPCFeatureFSqrt | PowerPCFeatureGPUL },
{ "generic", 0 }
};
/// Length of PowerPCSubTypeKV.
static const unsigned PowerPCSubTypeKVSize = sizeof(PowerPCSubTypeKV)
/ sizeof(SubtargetFeatureKV);
/// Sorted (by key) array of values for CPU features.
static SubtargetFeatureKV PowerPCFeatureKV[] = {
{ "64bit" , PowerPCFeature64Bit },
{ "altivec", PowerPCFeatureAltivec },
{ "fsqrt" , PowerPCFeatureFSqrt },
{ "gpul" , PowerPCFeatureGPUL }
};
/// Length of PowerPCFeatureKV.
static const unsigned PowerPCFeatureKVSize = sizeof(PowerPCFeatureKV)
/ sizeof(SubtargetFeatureKV);
#if defined(__APPLE__)
#include <mach/mach.h>
#include <mach/mach_host.h>
#include <mach/host_info.h>
#include <mach/machine.h>
static boolean_t IsGP() {
/// GetCurrentPowerPCFeatures - Returns the current CPUs features.
static const char *GetCurrentPowerPCCPU() {
host_basic_info_data_t hostInfo;
mach_msg_type_number_t infoCount;
@ -44,28 +92,52 @@ static boolean_t IsGP() {
host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo,
&infoCount);
return ((hostInfo.cpu_type == CPU_TYPE_POWERPC) &&
(hostInfo.cpu_subtype == CPU_SUBTYPE_POWERPC_970));
if (hostInfo.cpu_type != CPU_TYPE_POWERPC) return "generic";
switch(hostInfo.cpu_subtype) {
case CPU_SUBTYPE_POWERPC_601: return "601";
case CPU_SUBTYPE_POWERPC_602: return "602";
case CPU_SUBTYPE_POWERPC_603: return "603";
case CPU_SUBTYPE_POWERPC_603e: return "603e";
case CPU_SUBTYPE_POWERPC_603ev: return "603ev";
case CPU_SUBTYPE_POWERPC_604: return "604";
case CPU_SUBTYPE_POWERPC_604e: return "604e";
case CPU_SUBTYPE_POWERPC_620: return "620";
case CPU_SUBTYPE_POWERPC_750: return "750";
case CPU_SUBTYPE_POWERPC_7400: return "7400";
case CPU_SUBTYPE_POWERPC_7450: return "7450";
case CPU_SUBTYPE_POWERPC_970: return "970";
default: ;
}
return "generic";
}
#endif
PPCSubtarget::PPCSubtarget(const Module &M)
PPCSubtarget::PPCSubtarget(const Module &M, const std::string &FS)
: StackAlignment(16), IsGigaProcessor(false), IsAIX(false), IsDarwin(false) {
// Determine default and user specified characteristics
std::string CPU;
#if defined(__APPLE__)
CPU = GetCurrentPowerPCCPU();
#endif
uint32_t Bits =
SubtargetFeatures::Parse(FS, CPU,
PowerPCSubTypeKV, PowerPCSubTypeKVSize,
PowerPCFeatureKV, PowerPCFeatureKVSize);
IsGigaProcessor = (Bits & PowerPCFeatureGPUL) != 0;
// Set the boolean corresponding to the current target triple, or the default
// if one cannot be determined, to true.
const std::string& TT = M.getTargetTriple();
if (TT.length() > 5) {
IsDarwin = TT.find("darwin") != std::string::npos;
#if defined(__APPLE__)
IsGigaProcessor = IsGP();
#endif
} else if (TT.empty()) {
#if defined(_POWER)
IsAIX = true;
#elif defined(__APPLE__)
IsDarwin = true;
IsGigaProcessor = IsGP();
#endif
}

4
llvm/lib/Target/PowerPC/PPCSubtarget.h
View File

@ -16,6 +16,8 @@
#include "llvm/Target/TargetSubtarget.h"
#include <string>
namespace llvm {
class Module;
@ -33,7 +35,7 @@ public:
/// This constructor initializes the data members to match that
/// of the specified module.
///
PPCSubtarget(const Module &M);
PPCSubtarget(const Module &M, const std::string &FS);
/// getStackAlignment - Returns the minimum alignment known to hold of the
/// stack frame on entry to the function and which must be maintained by every

8
llvm/lib/Target/PowerPC/PowerPCTargetMachine.cpp
View File

@ -43,9 +43,10 @@ namespace {
PowerPCTargetMachine::PowerPCTargetMachine(const std::string &name,
IntrinsicLowering *IL,
const Module &M,
const std::string &FS,
const TargetData &TD,
const PowerPCFrameInfo &TFI)
: TargetMachine(name, IL, TD), FrameInfo(TFI), Subtarget(M) {
: TargetMachine(name, IL, TD), FrameInfo(TFI), Subtarget(M, FS) {
if (TargetDefault == PPCTarget) {
if (Subtarget.isAIX()) PPCTarget = TargetAIX;
if (Subtarget.isDarwin()) PPCTarget = TargetDarwin;
@ -154,8 +155,9 @@ void PowerPCJITInfo::addPassesToJITCompile(FunctionPassManager &PM) {
/// PowerPCTargetMachine ctor - Create an ILP32 architecture model
///
PPC32TargetMachine::PPC32TargetMachine(const Module &M, IntrinsicLowering *IL)
: PowerPCTargetMachine(PPC32ID, IL, M,
PPC32TargetMachine::PPC32TargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS)
: PowerPCTargetMachine(PPC32ID, IL, M, FS,
TargetData(PPC32ID,false,4,4,4,4,4,4,2,1,1),
PowerPCFrameInfo(*this, false)), JITInfo(*this) {}

3
llvm/lib/Target/PowerPC/PowerPCTargetMachine.h
View File

@ -30,7 +30,8 @@ class PowerPCTargetMachine : public TargetMachine {
PPCSubtarget Subtarget;
protected:
PowerPCTargetMachine(const std::string &name, IntrinsicLowering *IL,
const Module &M, const TargetData &TD,
const Module &M, const std::string &FS,
const TargetData &TD,
const PowerPCFrameInfo &TFI);
public:
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }

3
llvm/lib/Target/Skeleton/SkeletonTargetMachine.cpp
View File

@ -29,7 +29,8 @@ namespace {
/// SkeletonTargetMachine ctor - Create an ILP32 architecture model
///
SkeletonTargetMachine::SkeletonTargetMachine(const Module &M,
IntrinsicLowering *IL)
IntrinsicLowering *IL,
const std::string &FS)
: TargetMachine("Skeleton", IL, true, 4, 4, 4, 4, 4),
FrameInfo(TargetFrameInfo::StackGrowsDown, 8, -4), JITInfo(*this) {
}

3
llvm/lib/Target/Skeleton/SkeletonTargetMachine.h
View File

@ -28,7 +28,8 @@ namespace llvm {
TargetFrameInfo FrameInfo;
SkeletonJITInfo JITInfo;
public:
SkeletonTargetMachine(const Module &M, IntrinsicLowering *IL);
SkeletonTargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS);
virtual const SkeletonInstrInfo *getInstrInfo() const { return &InstrInfo; }
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }

3
llvm/lib/Target/SparcV8/SparcV8TargetMachine.cpp
View File

@ -31,7 +31,8 @@ namespace {
/// SparcV8TargetMachine ctor - Create an ILP32 architecture model
///
SparcV8TargetMachine::SparcV8TargetMachine(const Module &M,
IntrinsicLowering *IL)
IntrinsicLowering *IL,
const std::string &FS)
: TargetMachine("SparcV8", IL, false, 4, 4),
FrameInfo(TargetFrameInfo::StackGrowsDown, 8, 0), JITInfo(*this) {
}

3
llvm/lib/Target/SparcV8/SparcV8TargetMachine.h
View File

@ -30,7 +30,8 @@ class SparcV8TargetMachine : public TargetMachine {
TargetFrameInfo FrameInfo;
SparcV8JITInfo JITInfo;
public:
SparcV8TargetMachine(const Module &M, IntrinsicLowering *IL);
SparcV8TargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS);
virtual const SparcV8InstrInfo *getInstrInfo() const { return &InstrInfo; }
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }

3
llvm/lib/Target/SparcV9/SparcV9TargetMachine.cpp
View File

@ -148,7 +148,8 @@ FunctionPass *llvm::createSparcV9MachineCodeDestructionPass() {
SparcV9TargetMachine::SparcV9TargetMachine(const Module &M,
IntrinsicLowering *il)
IntrinsicLowering *il,
const std::string &FS)
: TargetMachine("UltraSparcV9-Native", il, false),
schedInfo(*this),
regInfo(*this),

3
llvm/lib/Target/SparcV9/SparcV9TargetMachine.h
View File

@ -32,7 +32,8 @@ class SparcV9TargetMachine : public TargetMachine {
SparcV9FrameInfo frameInfo;
SparcV9JITInfo jitInfo;
public:
SparcV9TargetMachine(const Module &M, IntrinsicLowering *IL);
SparcV9TargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS);
virtual const TargetInstrInfo *getInstrInfo() const { return &instrInfo; }
virtual const TargetSchedInfo *getSchedInfo() const { return &schedInfo; }

3
llvm/lib/Target/TargetMachineRegistry.cpp
View File

@ -26,7 +26,8 @@ const TargetMachineRegistry::Entry *TargetMachineRegistry::List = 0;
static TargetRegistrationListener *Listeners = 0;
TargetMachineRegistry::Entry::Entry(const char *N, const char *SD,
TargetMachine *(*CF)(const Module &, IntrinsicLowering*),
TargetMachine *(*CF)(const Module &, IntrinsicLowering*,
const std::string &),
unsigned (*MMF)(const Module &M), unsigned (*JMF)())
: Name(N), ShortDesc(SD), CtorFn(CF), ModuleMatchQualityFn(MMF),
JITMatchQualityFn(JMF), Next(List) {

2
llvm/lib/Target/X86/X86Subtarget.cpp
View File

@ -15,7 +15,7 @@
#include "llvm/Module.h"
using namespace llvm;
X86Subtarget::X86Subtarget(const Module &M)
X86Subtarget::X86Subtarget(const Module &M, const std::string &FS)
: TargetSubtarget(), stackAlignment(8),
indirectExternAndWeakGlobals(false), asmDarwinLinkerStubs(false),
asmLeadingUnderscore(false), asmAlignmentIsInBytes(false),

4
llvm/lib/Target/X86/X86Subtarget.h
View File

@ -16,6 +16,8 @@
#include "llvm/Target/TargetSubtarget.h"
#include <string>
namespace llvm {
class Module;
@ -39,7 +41,7 @@ public:
/// This constructor initializes the data members to match that
/// of the specified module.
///
X86Subtarget(const Module &M);
X86Subtarget(const Module &M, const std::string &FS);
/// getStackAlignment - Returns the minimum alignment known to hold of the
/// stack frame on entry to the function and which must be maintained by every

6
llvm/lib/Target/X86/X86TargetMachine.cpp
View File

@ -90,9 +90,11 @@ unsigned X86TargetMachine::getModuleMatchQuality(const Module &M) {
/// X86TargetMachine ctor - Create an ILP32 architecture model
///
X86TargetMachine::X86TargetMachine(const Module &M, IntrinsicLowering *IL)
X86TargetMachine::X86TargetMachine(const Module &M,
IntrinsicLowering *IL,
const std::string &FS)
: TargetMachine("X86", IL, true, 4, 4, 4, 4, 4),
Subtarget(M),
Subtarget(M, FS),
FrameInfo(TargetFrameInfo::StackGrowsDown,
Subtarget.getStackAlignment(), -4),
JITInfo(*this) {

3
llvm/lib/Target/X86/X86TargetMachine.h
View File

@ -30,7 +30,8 @@ class X86TargetMachine : public TargetMachine {
TargetFrameInfo FrameInfo;
X86JITInfo JITInfo;
public:
X86TargetMachine(const Module &M, IntrinsicLowering *IL);
X86TargetMachine(const Module &M, IntrinsicLowering *IL,
const std::string &FS);
virtual const X86InstrInfo *getInstrInfo() const { return &InstrInfo; }
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }

25
llvm/tools/llc/llc.cpp
View File

@ -14,6 +14,7 @@
//===----------------------------------------------------------------------===//
#include "llvm/Bytecode/Reader.h"
#include "llvm/Target/SubtargetFeature.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachineRegistry.h"
#include "llvm/Transforms/Scalar.h"
@ -47,6 +48,18 @@ static cl::opt<bool> Force("f", cl::desc("Overwrite output files"));
static cl::opt<const TargetMachineRegistry::Entry*, false, TargetNameParser>
MArch("march", cl::desc("Architecture to generate code for:"));
static cl::opt<std::string>
MCPU("mcpu",
cl::desc("Target a specific cpu type"),
cl::value_desc("cpu-name"),
cl::init(""));
static cl::list<std::string>
MAttrs("mattr",
cl::CommaSeparated,
cl::desc("Target specific attributes:"),
cl::value_desc("attributes"));
cl::opt<TargetMachine::CodeGenFileType>
FileType("filetype", cl::init(TargetMachine::AssemblyFile),
cl::desc("Choose a file type (not all types are supported by all targets):"),
@ -114,7 +127,17 @@ int main(int argc, char **argv) {
}
}
std::auto_ptr<TargetMachine> target(MArch->CtorFn(mod, 0));
// Package up features to be passed to target/subtarget
std::string FeaturesStr;
if (MCPU.size() || MAttrs.size()) {
SubtargetFeatures Features;
Features.setCPU(MCPU);
for (unsigned i = 0; i != MAttrs.size(); ++i)
Features.AddFeature(MAttrs[i]);
FeaturesStr = Features.getString();
}
std::auto_ptr<TargetMachine> target(MArch->CtorFn(mod, 0, FeaturesStr));
assert(target.get() && "Could not allocate target machine!");
TargetMachine &Target = *target.get();
const TargetData &TD = Target.getTargetData();