diff --git a/Xcode/LLVM.xcodeproj/project.pbxproj b/Xcode/LLVM.xcodeproj/project.pbxproj
index ad6eda3..30394ae 100644
--- a/Xcode/LLVM.xcodeproj/project.pbxproj
+++ b/Xcode/LLVM.xcodeproj/project.pbxproj
@@ -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;
diff --git a/include/llvm/Target/TargetMachineRegistry.h b/include/llvm/Target/TargetMachineRegistry.h
index 6de84bc..77aecd7 100644
--- a/include/llvm/Target/TargetMachineRegistry.h
+++ b/include/llvm/Target/TargetMachineRegistry.h
@@ -49,7 +49,8 @@
     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 @@
 
     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 @@
                                    &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);
     }
   };
 
diff --git a/lib/ExecutionEngine/JIT/TargetSelect.cpp b/lib/ExecutionEngine/JIT/TargetSelect.cpp
index 851b4b4..5b1ee74 100644
--- a/lib/ExecutionEngine/JIT/TargetSelect.cpp
+++ b/lib/ExecutionEngine/JIT/TargetSelect.cpp
@@ -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 @@
 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 @@
               << "-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.
diff --git a/lib/Target/Alpha/AlphaTargetMachine.cpp b/lib/Target/Alpha/AlphaTargetMachine.cpp
index 0854f2a..b20cfd3 100644
--- a/lib/Target/Alpha/AlphaTargetMachine.cpp
+++ b/lib/Target/Alpha/AlphaTargetMachine.cpp
@@ -58,7 +58,8 @@
 #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)
diff --git a/lib/Target/Alpha/AlphaTargetMachine.h b/lib/Target/Alpha/AlphaTargetMachine.h
index b7f824e..4de729a 100644
--- a/lib/Target/Alpha/AlphaTargetMachine.h
+++ b/lib/Target/Alpha/AlphaTargetMachine.h
@@ -31,7 +31,8 @@
   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; }
diff --git a/lib/Target/CBackend/CTargetMachine.h b/lib/Target/CBackend/CTargetMachine.h
index 56c5367..580e02e 100644
--- a/lib/Target/CBackend/CTargetMachine.h
+++ b/lib/Target/CBackend/CTargetMachine.h
@@ -20,7 +20,8 @@
 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.
diff --git a/lib/Target/IA64/IA64TargetMachine.cpp b/lib/Target/IA64/IA64TargetMachine.cpp
index 6a7ae6e..7d80e57 100644
--- a/lib/Target/IA64/IA64TargetMachine.cpp
+++ b/lib/Target/IA64/IA64TargetMachine.cpp
@@ -72,7 +72,8 @@
 
 /// 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
 }
diff --git a/lib/Target/IA64/IA64TargetMachine.h b/lib/Target/IA64/IA64TargetMachine.h
index ed80828..df6e4df 100644
--- a/lib/Target/IA64/IA64TargetMachine.h
+++ b/lib/Target/IA64/IA64TargetMachine.h
@@ -27,7 +27,8 @@
   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; }
diff --git a/lib/Target/PowerPC/PPCSubtarget.cpp b/lib/Target/PowerPC/PPCSubtarget.cpp
index 686c11c..2c1b783 100644
--- a/lib/Target/PowerPC/PPCSubtarget.cpp
+++ b/lib/Target/PowerPC/PPCSubtarget.cpp
@@ -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,42 +32,112 @@
                              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;
 
   infoCount = HOST_BASIC_INFO_COUNT;
   host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo, 
             &infoCount);
+            
+  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 ((hostInfo.cpu_type == CPU_TYPE_POWERPC) &&
-          (hostInfo.cpu_subtype == CPU_SUBTYPE_POWERPC_970));
-} 
+  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) {
 
-    // Set the boolean corresponding to the current target triple, or the default
+  // 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
   }
   
diff --git a/lib/Target/PowerPC/PPCSubtarget.h b/lib/Target/PowerPC/PPCSubtarget.h
index 60308f0..aaf07f9 100644
--- a/lib/Target/PowerPC/PPCSubtarget.h
+++ b/lib/Target/PowerPC/PPCSubtarget.h
@@ -16,6 +16,8 @@
 
 #include "llvm/Target/TargetSubtarget.h"
 
+#include <string>
+
 namespace llvm {
 class Module;
 
@@ -33,7 +35,7 @@
   /// 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
diff --git a/lib/Target/PowerPC/PPCTargetMachine.cpp b/lib/Target/PowerPC/PPCTargetMachine.cpp
index 936629a..8ff9d8b 100644
--- a/lib/Target/PowerPC/PPCTargetMachine.cpp
+++ b/lib/Target/PowerPC/PPCTargetMachine.cpp
@@ -43,9 +43,10 @@
 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 @@
 
 /// 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) {}
 
diff --git a/lib/Target/PowerPC/PPCTargetMachine.h b/lib/Target/PowerPC/PPCTargetMachine.h
index 9b16713..902abb0 100644
--- a/lib/Target/PowerPC/PPCTargetMachine.h
+++ b/lib/Target/PowerPC/PPCTargetMachine.h
@@ -28,7 +28,8 @@
   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();
diff --git a/lib/Target/PowerPC/PowerPCTargetMachine.h b/lib/Target/PowerPC/PowerPCTargetMachine.h
index 4a92acf..0c12f30 100644
--- a/lib/Target/PowerPC/PowerPCTargetMachine.h
+++ b/lib/Target/PowerPC/PowerPCTargetMachine.h
@@ -30,7 +30,8 @@
   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; }
diff --git a/lib/Target/Skeleton/SkeletonTargetMachine.cpp b/lib/Target/Skeleton/SkeletonTargetMachine.cpp
index 8b7a8db..df27b77 100644
--- a/lib/Target/Skeleton/SkeletonTargetMachine.cpp
+++ b/lib/Target/Skeleton/SkeletonTargetMachine.cpp
@@ -29,7 +29,8 @@
 /// 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) {
 }
diff --git a/lib/Target/Skeleton/SkeletonTargetMachine.h b/lib/Target/Skeleton/SkeletonTargetMachine.h
index 0480a6e..0607b6f 100644
--- a/lib/Target/Skeleton/SkeletonTargetMachine.h
+++ b/lib/Target/Skeleton/SkeletonTargetMachine.h
@@ -28,7 +28,8 @@
     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; }
diff --git a/lib/Target/Sparc/SparcTargetMachine.cpp b/lib/Target/Sparc/SparcTargetMachine.cpp
index 75c095c..54895fe 100644
--- a/lib/Target/Sparc/SparcTargetMachine.cpp
+++ b/lib/Target/Sparc/SparcTargetMachine.cpp
@@ -31,7 +31,8 @@
 /// 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) {
 }
diff --git a/lib/Target/Sparc/SparcTargetMachine.h b/lib/Target/Sparc/SparcTargetMachine.h
index 47218e7..3ec07a3 100644
--- a/lib/Target/Sparc/SparcTargetMachine.h
+++ b/lib/Target/Sparc/SparcTargetMachine.h
@@ -30,7 +30,8 @@
   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; }
diff --git a/lib/Target/SparcV8/SparcV8TargetMachine.cpp b/lib/Target/SparcV8/SparcV8TargetMachine.cpp
index 75c095c..54895fe 100644
--- a/lib/Target/SparcV8/SparcV8TargetMachine.cpp
+++ b/lib/Target/SparcV8/SparcV8TargetMachine.cpp
@@ -31,7 +31,8 @@
 /// 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) {
 }
diff --git a/lib/Target/SparcV8/SparcV8TargetMachine.h b/lib/Target/SparcV8/SparcV8TargetMachine.h
index 47218e7..3ec07a3 100644
--- a/lib/Target/SparcV8/SparcV8TargetMachine.h
+++ b/lib/Target/SparcV8/SparcV8TargetMachine.h
@@ -30,7 +30,8 @@
   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; }
diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.cpp b/lib/Target/SparcV9/SparcV9TargetMachine.cpp
index fb12f18..9e86a75 100644
--- a/lib/Target/SparcV9/SparcV9TargetMachine.cpp
+++ b/lib/Target/SparcV9/SparcV9TargetMachine.cpp
@@ -148,7 +148,8 @@
 
 
 SparcV9TargetMachine::SparcV9TargetMachine(const Module &M,
-                                           IntrinsicLowering *il)
+                                           IntrinsicLowering *il,
+                                           const std::string &FS)
   : TargetMachine("UltraSparcV9-Native", il, false),
     schedInfo(*this),
     regInfo(*this),
diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.h b/lib/Target/SparcV9/SparcV9TargetMachine.h
index cde7199..9f40339 100644
--- a/lib/Target/SparcV9/SparcV9TargetMachine.h
+++ b/lib/Target/SparcV9/SparcV9TargetMachine.h
@@ -32,7 +32,8 @@
   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; }
diff --git a/lib/Target/TargetMachineRegistry.cpp b/lib/Target/TargetMachineRegistry.cpp
index f753a8c..f5bd035 100644
--- a/lib/Target/TargetMachineRegistry.cpp
+++ b/lib/Target/TargetMachineRegistry.cpp
@@ -26,7 +26,8 @@
 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) {
diff --git a/lib/Target/X86/X86Subtarget.cpp b/lib/Target/X86/X86Subtarget.cpp
index ed8b871..7a4a178 100644
--- a/lib/Target/X86/X86Subtarget.cpp
+++ b/lib/Target/X86/X86Subtarget.cpp
@@ -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),
diff --git a/lib/Target/X86/X86Subtarget.h b/lib/Target/X86/X86Subtarget.h
index bf764d3..adbc7cb 100644
--- a/lib/Target/X86/X86Subtarget.h
+++ b/lib/Target/X86/X86Subtarget.h
@@ -16,6 +16,8 @@
 
 #include "llvm/Target/TargetSubtarget.h"
 
+#include <string>
+
 namespace llvm {
 class Module;
 
@@ -39,7 +41,7 @@
   /// 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
diff --git a/lib/Target/X86/X86TargetMachine.cpp b/lib/Target/X86/X86TargetMachine.cpp
index e5a4fc8..29ff15f 100644
--- a/lib/Target/X86/X86TargetMachine.cpp
+++ b/lib/Target/X86/X86TargetMachine.cpp
@@ -90,9 +90,11 @@
 
 /// 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) {
diff --git a/lib/Target/X86/X86TargetMachine.h b/lib/Target/X86/X86TargetMachine.h
index 955f855..333d655 100644
--- a/lib/Target/X86/X86TargetMachine.h
+++ b/lib/Target/X86/X86TargetMachine.h
@@ -30,7 +30,8 @@
   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; }
diff --git a/tools/llc/llc.cpp b/tools/llc/llc.cpp
index 8331ecf..fbd2cf8 100644
--- a/tools/llc/llc.cpp
+++ b/tools/llc/llc.cpp
@@ -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<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 @@
       }
     }
 
-    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();