Update clang to r93512.

1 files changed, 222 insertions, 234 deletions

diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp
index b6b5c6c..bba2c3f 100644
--- a/lib/Basic/Targets.cpp
+++ b/lib/Basic/Targets.cpp
@@ -18,51 +18,38 @@
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetOptions.h"
+#include "clang/Frontend/Utils.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/MC/MCSectionMachO.h"
+#include <algorithm>
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 //  Common code shared among targets.
 //===----------------------------------------------------------------------===//
 
-static void Define(std::vector<char> &Buf, const llvm::StringRef &Macro,
-                   const llvm::StringRef &Val = "1") {
-  const char *Def = "#define ";
-  Buf.insert(Buf.end(), Def, Def+strlen(Def));
-  Buf.insert(Buf.end(), Macro.begin(), Macro.end());
-  Buf.push_back(' ');
-  Buf.insert(Buf.end(), Val.begin(), Val.end());
-  Buf.push_back('\n');
-}
-
 /// DefineStd - Define a macro name and standard variants.  For example if
 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
 /// when in GNU mode.
-static void DefineStd(std::vector<char> &Buf, const char *MacroName,
+static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
                       const LangOptions &Opts) {
   assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
 
   // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
   // in the user's namespace.
   if (Opts.GNUMode)
-    Define(Buf, MacroName);
+    Builder.defineMacro(MacroName);
 
   // Define __unix.
-  llvm::SmallString<20> TmpStr;
-  TmpStr = "__";
-  TmpStr += MacroName;
-  Define(Buf, TmpStr.str());
+  Builder.defineMacro("__" + MacroName);
 
   // Define __unix__.
-  TmpStr += "__";
-  Define(Buf, TmpStr.str());
+  Builder.defineMacro("__" + MacroName + "__");
 }
 
 //===----------------------------------------------------------------------===//
@@ -74,44 +61,44 @@ template<typename TgtInfo>
 class OSTargetInfo : public TgtInfo {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                            std::vector<char> &Defines) const=0;
+                            MacroBuilder &Builder) const=0;
 public:
   OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    TgtInfo::getTargetDefines(Opts, Defines);
-    getOSDefines(Opts, TgtInfo::getTriple(), Defines);
+                                MacroBuilder &Builder) const {
+    TgtInfo::getTargetDefines(Opts, Builder);
+    getOSDefines(Opts, TgtInfo::getTriple(), Builder);
   }
 
 };
 } // end anonymous namespace
 
 
-static void getDarwinDefines(std::vector<char> &Defs, const LangOptions &Opts) {
-  Define(Defs, "__APPLE_CC__", "5621");
-  Define(Defs, "__APPLE__");
-  Define(Defs, "__MACH__");
-  Define(Defs, "OBJC_NEW_PROPERTIES");
+static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts) {
+  Builder.defineMacro("__APPLE_CC__", "5621");
+  Builder.defineMacro("__APPLE__");
+  Builder.defineMacro("__MACH__");
+  Builder.defineMacro("OBJC_NEW_PROPERTIES");
 
   // __weak is always defined, for use in blocks and with objc pointers.
-  Define(Defs, "__weak", "__attribute__((objc_gc(weak)))");
+  Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
 
   // Darwin defines __strong even in C mode (just to nothing).
   if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
-    Define(Defs, "__strong", "");
+    Builder.defineMacro("__strong", "");
   else
-    Define(Defs, "__strong", "__attribute__((objc_gc(strong)))");
+    Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
 
   if (Opts.Static)
-    Define(Defs, "__STATIC__");
+    Builder.defineMacro("__STATIC__");
   else
-    Define(Defs, "__DYNAMIC__");
+    Builder.defineMacro("__DYNAMIC__");
 
   if (Opts.POSIXThreads)
-    Define(Defs, "_REENTRANT", "1");
+    Builder.defineMacro("_REENTRANT");
 }
 
-static void getDarwinOSXDefines(std::vector<char> &Defs,
+static void getDarwinOSXDefines(MacroBuilder &Builder,
                                 const llvm::Triple &Triple) {
   if (Triple.getOS() != llvm::Triple::Darwin)
     return;
@@ -129,10 +116,11 @@ static void getDarwinOSXDefines(std::vector<char> &Defs,
   // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
   // Cap 10.4.11 -> darwin8.11 -> "1049"
   MacOSXStr[3] = std::min(Min, 9U)+'0';
-  Define(Defs, "__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", MacOSXStr);
+  Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__",
+                      MacOSXStr);
 }
 
-static void getDarwinIPhoneOSDefines(std::vector<char> &Defs,
+static void getDarwinIPhoneOSDefines(MacroBuilder &Builder,
                                      const llvm::Triple &Triple) {
   if (Triple.getOS() != llvm::Triple::Darwin)
     return;
@@ -151,8 +139,8 @@ static void getDarwinIPhoneOSDefines(std::vector<char> &Defs,
 
   // Handle minor version: 2.2 -> darwin9.2.2 -> 20200
   iPhoneOSStr[2] = std::min(Rev, 9U)+'0';
-  Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
-         iPhoneOSStr);
+  Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
+                      iPhoneOSStr);
 }
 
 namespace {
@@ -160,9 +148,9 @@ template<typename Target>
 class DarwinTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                    std::vector<char> &Defines) const {
-    getDarwinDefines(Defines, Opts);
-    getDarwinOSXDefines(Defines, Triple);
+                            MacroBuilder &Builder) const {
+    getDarwinDefines(Builder, Opts);
+    getDarwinOSXDefines(Builder, Triple);
   }
 
 public:
@@ -190,14 +178,14 @@ template<typename Target>
 class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                    std::vector<char> &Defs) const {
+                            MacroBuilder &Builder) const {
     // DragonFly defines; list based off of gcc output
-    Define(Defs, "__DragonFly__");
-    Define(Defs, "__DragonFly_cc_version", "100001");
-    Define(Defs, "__ELF__");
-    Define(Defs, "__KPRINTF_ATTRIBUTE__");
-    Define(Defs, "__tune_i386__");
-    DefineStd(Defs, "unix", Opts);
+    Builder.defineMacro("__DragonFly__");
+    Builder.defineMacro("__DragonFly_cc_version", "100001");
+    Builder.defineMacro("__ELF__");
+    Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
+    Builder.defineMacro("__tune_i386__");
+    DefineStd(Builder, "unix", Opts);
   }
 public:
   DragonFlyBSDTargetInfo(const std::string &triple)
@@ -209,7 +197,7 @@ template<typename Target>
 class FreeBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                    std::vector<char> &Defs) const {
+                            MacroBuilder &Builder) const {
     // FreeBSD defines; list based off of gcc output
 
     // FIXME: Move version number handling to llvm::Triple.
@@ -221,11 +209,11 @@ protected:
     char version[] = "X00001";
     version[0] = FreeBSD[0];
 
-    Define(Defs, "__FreeBSD__", release);
-    Define(Defs, "__FreeBSD_cc_version", version);
-    Define(Defs, "__KPRINTF_ATTRIBUTE__");
-    DefineStd(Defs, "unix", Opts);
-    Define(Defs, "__ELF__", "1");
+    Builder.defineMacro("__FreeBSD__", release);
+    Builder.defineMacro("__FreeBSD_cc_version", version);
+    Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
+    DefineStd(Builder, "unix", Opts);
+    Builder.defineMacro("__ELF__");
   }
 public:
   FreeBSDTargetInfo(const std::string &triple)
@@ -239,14 +227,14 @@ template<typename Target>
 class LinuxTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                           std::vector<char> &Defs) const {
+                            MacroBuilder &Builder) const {
     // Linux defines; list based off of gcc output
-    DefineStd(Defs, "unix", Opts);
-    DefineStd(Defs, "linux", Opts);
-    Define(Defs, "__gnu_linux__");
-    Define(Defs, "__ELF__", "1");
+    DefineStd(Builder, "unix", Opts);
+    DefineStd(Builder, "linux", Opts);
+    Builder.defineMacro("__gnu_linux__");
+    Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
-      Define(Defs, "_REENTRANT", "1");
+      Builder.defineMacro("_REENTRANT");
   }
 public:
   LinuxTargetInfo(const std::string& triple)
@@ -260,13 +248,13 @@ template<typename Target>
 class NetBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                    std::vector<char> &Defs) const {
+                            MacroBuilder &Builder) const {
     // NetBSD defines; list based off of gcc output
-    Define(Defs, "__NetBSD__", "1");
-    Define(Defs, "__unix__", "1");
-    Define(Defs, "__ELF__", "1");
+    Builder.defineMacro("__NetBSD__");
+    Builder.defineMacro("__unix__");
+    Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
-      Define(Defs, "_POSIX_THREADS", "1");
+      Builder.defineMacro("_POSIX_THREADS");
   }
 public:
   NetBSDTargetInfo(const std::string &triple)
@@ -280,14 +268,14 @@ template<typename Target>
 class OpenBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                    std::vector<char> &Defs) const {
+                            MacroBuilder &Builder) const {
     // OpenBSD defines; list based off of gcc output
 
-    Define(Defs, "__OpenBSD__", "1");
-    DefineStd(Defs, "unix", Opts);
-    Define(Defs, "__ELF__", "1");
+    Builder.defineMacro("__OpenBSD__");
+    DefineStd(Builder, "unix", Opts);
+    Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
-      Define(Defs, "_POSIX_THREADS", "1");
+      Builder.defineMacro("_POSIX_THREADS");
   }
 public:
   OpenBSDTargetInfo(const std::string &triple)
@@ -299,12 +287,12 @@ template<typename Target>
 class PSPTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                           std::vector<char> &Defs) const {
+                            MacroBuilder &Builder) const {
     // PSP defines; list based on the output of the pspdev gcc toolchain.
-    Define(Defs, "PSP", "1");
-    Define(Defs, "_PSP", "1");
-    Define(Defs, "__psp__", "1");
-    Define(Defs, "__ELF__", "1");
+    Builder.defineMacro("PSP");
+    Builder.defineMacro("_PSP");
+    Builder.defineMacro("__psp__");
+    Builder.defineMacro("__ELF__");
   }
 public:
   PSPTargetInfo(const std::string& triple)
@@ -318,12 +306,12 @@ template<typename Target>
 class PS3PPUTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                           std::vector<char> &Defs) const {
+                            MacroBuilder &Builder) const {
     // PS3 PPU defines.
-    Define(Defs, "__PPU__", "1");
-    Define(Defs, "__CELLOS_LV2__", "1");
-    Define(Defs, "__ELF__", "1");
-    Define(Defs, "__LP32__", "1");
+    Builder.defineMacro("__PPU__");
+    Builder.defineMacro("__CELLOS_LV2__");
+    Builder.defineMacro("__ELF__");
+    Builder.defineMacro("__LP32__");
   }
 public:
   PS3PPUTargetInfo(const std::string& triple)
@@ -340,10 +328,10 @@ template<typename Target>
 class PS3SPUTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                           std::vector<char> &Defs) const {
+                            MacroBuilder &Builder) const {
     // PS3 PPU defines.
-    Define(Defs, "__SPU__", "1");
-    Define(Defs, "__ELF__", "1");
+    Builder.defineMacro("__SPU__");
+    Builder.defineMacro("__ELF__");
   }
 public:
   PS3SPUTargetInfo(const std::string& triple)
@@ -357,12 +345,12 @@ template<typename Target>
 class AuroraUXTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                                std::vector<char> &Defs) const {
-    DefineStd(Defs, "sun", Opts);
-    DefineStd(Defs, "unix", Opts);
-    Define(Defs, "__ELF__");
-    Define(Defs, "__svr4__");
-    Define(Defs, "__SVR4");
+                            MacroBuilder &Builder) const {
+    DefineStd(Builder, "sun", Opts);
+    DefineStd(Builder, "unix", Opts);
+    Builder.defineMacro("__ELF__");
+    Builder.defineMacro("__svr4__");
+    Builder.defineMacro("__SVR4");
   }
 public:
   AuroraUXTargetInfo(const std::string& triple)
@@ -378,12 +366,12 @@ template<typename Target>
 class SolarisTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                                std::vector<char> &Defs) const {
-    DefineStd(Defs, "sun", Opts);
-    DefineStd(Defs, "unix", Opts);
-    Define(Defs, "__ELF__");
-    Define(Defs, "__svr4__");
-    Define(Defs, "__SVR4");
+                            MacroBuilder &Builder) const {
+    DefineStd(Builder, "sun", Opts);
+    DefineStd(Builder, "unix", Opts);
+    Builder.defineMacro("__ELF__");
+    Builder.defineMacro("__svr4__");
+    Builder.defineMacro("__SVR4");
   }
 public:
   SolarisTargetInfo(const std::string& triple)
@@ -416,7 +404,7 @@ public:
   }
 
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const;
+                                MacroBuilder &Builder) const;
 
   virtual const char *getVAListDeclaration() const {
     return "typedef char* __builtin_va_list;";
@@ -460,34 +448,34 @@ const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
 /// #defines that are not tied to a specific subtarget.
 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
-                                     std::vector<char> &Defs) const {
+                                     MacroBuilder &Builder) const {
   // Target identification.
-  Define(Defs, "__ppc__");
-  Define(Defs, "_ARCH_PPC");
-  Define(Defs, "__POWERPC__");
+  Builder.defineMacro("__ppc__");
+  Builder.defineMacro("_ARCH_PPC");
+  Builder.defineMacro("__POWERPC__");
   if (PointerWidth == 64) {
-    Define(Defs, "_ARCH_PPC64");
-    Define(Defs, "_LP64");
-    Define(Defs, "__LP64__");
-    Define(Defs, "__ppc64__");
+    Builder.defineMacro("_ARCH_PPC64");
+    Builder.defineMacro("_LP64");
+    Builder.defineMacro("__LP64__");
+    Builder.defineMacro("__ppc64__");
   } else {
-    Define(Defs, "__ppc__");
+    Builder.defineMacro("__ppc__");
   }
 
   // Target properties.
-  Define(Defs, "_BIG_ENDIAN");
-  Define(Defs, "__BIG_ENDIAN__");
+  Builder.defineMacro("_BIG_ENDIAN");
+  Builder.defineMacro("__BIG_ENDIAN__");
 
   // Subtarget options.
-  Define(Defs, "__NATURAL_ALIGNMENT__");
-  Define(Defs, "__REGISTER_PREFIX__", "");
+  Builder.defineMacro("__NATURAL_ALIGNMENT__");
+  Builder.defineMacro("__REGISTER_PREFIX__", "");
 
   // FIXME: Should be controlled by command line option.
-  Define(Defs, "__LONG_DOUBLE_128__");
+  Builder.defineMacro("__LONG_DOUBLE_128__");
   
   if (Opts.AltiVec) {
-    Define(Defs, "__VEC__", "10206");
-    Define(Defs, "__ALTIVEC__", "1");
+    Builder.defineMacro("__VEC__", "10206");
+    Builder.defineMacro("__ALTIVEC__");
   }
 }
 
@@ -682,7 +670,7 @@ public:
     return "~{dirflag},~{fpsr},~{flags}";
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const;
+                                MacroBuilder &Builder) const;
   virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
                                  const std::string &Name,
                                  bool Enabled) const;
@@ -828,51 +816,51 @@ void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
 /// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
 /// that are not tied to a specific subtarget.
 void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
-                                     std::vector<char> &Defs) const {
+                                     MacroBuilder &Builder) const {
   // Target identification.
   if (PointerWidth == 64) {
-    Define(Defs, "_LP64");
-    Define(Defs, "__LP64__");
-    Define(Defs, "__amd64__");
-    Define(Defs, "__amd64");
-    Define(Defs, "__x86_64");
-    Define(Defs, "__x86_64__");
+    Builder.defineMacro("_LP64");
+    Builder.defineMacro("__LP64__");
+    Builder.defineMacro("__amd64__");
+    Builder.defineMacro("__amd64");
+    Builder.defineMacro("__x86_64");
+    Builder.defineMacro("__x86_64__");
   } else {
-    DefineStd(Defs, "i386", Opts);
+    DefineStd(Builder, "i386", Opts);
   }
 
   // Target properties.
-  Define(Defs, "__LITTLE_ENDIAN__");
+  Builder.defineMacro("__LITTLE_ENDIAN__");
 
   // Subtarget options.
-  Define(Defs, "__nocona");
-  Define(Defs, "__nocona__");
-  Define(Defs, "__tune_nocona__");
-  Define(Defs, "__REGISTER_PREFIX__", "");
+  Builder.defineMacro("__nocona");
+  Builder.defineMacro("__nocona__");
+  Builder.defineMacro("__tune_nocona__");
+  Builder.defineMacro("__REGISTER_PREFIX__", "");
 
   // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
   // functions in glibc header files that use FP Stack inline asm which the
   // backend can't deal with (PR879).
-  Define(Defs, "__NO_MATH_INLINES");
+  Builder.defineMacro("__NO_MATH_INLINES");
 
   // Each case falls through to the previous one here.
   switch (SSELevel) {
   case SSE42:
-    Define(Defs, "__SSE4_2__");
+    Builder.defineMacro("__SSE4_2__");
   case SSE41:
-    Define(Defs, "__SSE4_1__");
+    Builder.defineMacro("__SSE4_1__");
   case SSSE3:
-    Define(Defs, "__SSSE3__");
+    Builder.defineMacro("__SSSE3__");
   case SSE3:
-    Define(Defs, "__SSE3__");
+    Builder.defineMacro("__SSE3__");
   case SSE2:
-    Define(Defs, "__SSE2__");
-    Define(Defs, "__SSE2_MATH__");  // -mfp-math=sse always implied.
+    Builder.defineMacro("__SSE2__");
+    Builder.defineMacro("__SSE2_MATH__");  // -mfp-math=sse always implied.
   case SSE1:
-    Define(Defs, "__SSE__");
-    Define(Defs, "__SSE_MATH__");   // -mfp-math=sse always implied.
+    Builder.defineMacro("__SSE__");
+    Builder.defineMacro("__SSE_MATH__");   // -mfp-math=sse always implied.
   case MMX:
-    Define(Defs, "__MMX__");
+    Builder.defineMacro("__MMX__");
   case NoMMXSSE:
     break;
   }
@@ -999,13 +987,13 @@ public:
                         "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    X86_32TargetInfo::getTargetDefines(Opts, Defines);
+                                MacroBuilder &Builder) const {
+    X86_32TargetInfo::getTargetDefines(Opts, Builder);
     // This list is based off of the the list of things MingW defines
-    Define(Defines, "_WIN32");
-    DefineStd(Defines, "WIN32", Opts);
-    DefineStd(Defines, "WINNT", Opts);
-    Define(Defines, "_X86_");
+    Builder.defineMacro("_WIN32");
+    DefineStd(Builder, "WIN32", Opts);
+    DefineStd(Builder, "WINNT", Opts);
+    Builder.defineMacro("_X86_");
   }
 };
 } // end anonymous namespace
@@ -1019,12 +1007,12 @@ public:
     : WindowsX86_32TargetInfo(triple) {
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    WindowsX86_32TargetInfo::getTargetDefines(Opts, Defines);
+                                MacroBuilder &Builder) const {
+    WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
     // The value of the following reflects processor type.
     // 300=386, 400=486, 500=Pentium, 600=Blend (default)
     // We lost the original triple, so we use the default.
-    Define(Defines, "_M_IX86", "600");
+    Builder.defineMacro("_M_IX86", "600");
   }
 };
 } // end anonymous namespace
@@ -1037,11 +1025,11 @@ public:
     : WindowsX86_32TargetInfo(triple) {
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    WindowsX86_32TargetInfo::getTargetDefines(Opts, Defines);
-    Define(Defines, "__MSVCRT__");
-    Define(Defines, "__MINGW32__");
-    Define(Defines, "__declspec", "__declspec");
+                                MacroBuilder &Builder) const {
+    WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
+    Builder.defineMacro("__MSVCRT__");
+    Builder.defineMacro("__MINGW32__");
+    Builder.defineMacro("__declspec", "__declspec");
   }
 };
 } // end anonymous namespace
@@ -1060,11 +1048,11 @@ public:
                         "a0:0:64-f80:32:32-n8:16:32";
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    X86_32TargetInfo::getTargetDefines(Opts, Defines);
-    Define(Defines, "__CYGWIN__");
-    Define(Defines, "__CYGWIN32__");
-    DefineStd(Defines, "unix", Opts);
+                                MacroBuilder &Builder) const {
+    X86_32TargetInfo::getTargetDefines(Opts, Builder);
+    Builder.defineMacro("__CYGWIN__");
+    Builder.defineMacro("__CYGWIN32__");
+    DefineStd(Builder, "unix", Opts);
   }
 };
 } // end anonymous namespace
@@ -1116,10 +1104,10 @@ public:
     DoubleAlign = LongLongAlign = 64;
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    X86_64TargetInfo::getTargetDefines(Opts, Defines);
-    Define(Defines, "_WIN64");
-    DefineStd(Defines, "WIN64", Opts);
+                                MacroBuilder &Builder) const {
+    X86_64TargetInfo::getTargetDefines(Opts, Builder);
+    Builder.defineMacro("_WIN64");
+    DefineStd(Builder, "WIN64", Opts);
   }
 };
 } // end anonymous namespace
@@ -1132,9 +1120,9 @@ public:
     : WindowsX86_64TargetInfo(triple) {
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    WindowsX86_64TargetInfo::getTargetDefines(Opts, Defines);
-    Define(Defines, "_M_X64");
+                                MacroBuilder &Builder) const {
+    WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
+    Builder.defineMacro("_M_X64");
   }
   virtual const char *getVAListDeclaration() const {
     return "typedef char* va_list;";
@@ -1150,11 +1138,11 @@ public:
     : WindowsX86_64TargetInfo(triple) {
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    WindowsX86_64TargetInfo::getTargetDefines(Opts, Defines);
-    Define(Defines, "__MSVCRT__");
-    Define(Defines, "__MINGW64__");
-    Define(Defines, "__declspec");
+                                MacroBuilder &Builder) const {
+    WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
+    Builder.defineMacro("__MSVCRT__");
+    Builder.defineMacro("__MINGW64__");
+    Builder.defineMacro("__declspec");
   }
 };
 } // end anonymous namespace
@@ -1342,61 +1330,58 @@ public:
     return true;
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defs) const {
+                                MacroBuilder &Builder) const {
     // Target identification.
-    Define(Defs, "__arm");
-    Define(Defs, "__arm__");
+    Builder.defineMacro("__arm");
+    Builder.defineMacro("__arm__");
 
     // Target properties.
-    Define(Defs, "__ARMEL__");
-    Define(Defs, "__LITTLE_ENDIAN__");
-    Define(Defs, "__REGISTER_PREFIX__", "");
+    Builder.defineMacro("__ARMEL__");
+    Builder.defineMacro("__LITTLE_ENDIAN__");
+    Builder.defineMacro("__REGISTER_PREFIX__", "");
 
     llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
-    std::string ArchName = "__ARM_ARCH_";
-    ArchName += CPUArch;
-    ArchName += "__";
-    Define(Defs, ArchName);
+    Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
 
     // Subtarget options.
 
     // FIXME: It's more complicated than this and we don't really support
     // interworking.
     if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
-      Define(Defs, "__THUMB_INTERWORK__");
+      Builder.defineMacro("__THUMB_INTERWORK__");
 
     if (ABI == "aapcs" || ABI == "aapcs-linux")
-      Define(Defs, "__ARM_EABI__");
+      Builder.defineMacro("__ARM_EABI__");
 
     if (SoftFloat)
-      Define(Defs, "__SOFTFP__");
+      Builder.defineMacro("__SOFTFP__");
 
     if (CPU == "xscale")
-      Define(Defs, "__XSCALE__");
+      Builder.defineMacro("__XSCALE__");
 
     bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
     if (IsThumb) {
-      Define(Defs, "__THUMBEL__");
-      Define(Defs, "__thumb__");
+      Builder.defineMacro("__THUMBEL__");
+      Builder.defineMacro("__thumb__");
       if (IsThumb2)
-        Define(Defs, "__thumb2__");
+        Builder.defineMacro("__thumb2__");
     }
 
     // Note, this is always on in gcc, even though it doesn't make sense.
-    Define(Defs, "__APCS_32__");
+    Builder.defineMacro("__APCS_32__");
 
     if (FPUModeIsVFP((FPUMode) FPU))
-      Define(Defs, "__VFP_FP__");
+      Builder.defineMacro("__VFP_FP__");
 
     // This only gets set when Neon instructions are actually available, unlike
     // the VFP define, hence the soft float and arch check. This is subtly
     // different from gcc, we follow the intent which was that it should be set
     // when Neon instructions are actually available.
     if (FPU == NeonFPU && !SoftFloat && IsThumb2)
-      Define(Defs, "__ARM_NEON__");
+      Builder.defineMacro("__ARM_NEON__");
 
     if (getTriple().getOS() == llvm::Triple::Darwin)
-      Define(Defs, "__USING_SJLJ_EXCEPTIONS__");
+      Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
   }
   virtual void getTargetBuiltins(const Builtin::Info *&Records,
                                  unsigned &NumRecords) const {
@@ -1475,9 +1460,9 @@ class DarwinARMTargetInfo :
   public DarwinTargetInfo<ARMTargetInfo> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
-                    std::vector<char> &Defines) const {
-    getDarwinDefines(Defines, Opts);
-    getDarwinIPhoneOSDefines(Defines, Triple);
+                            MacroBuilder &Builder) const {
+    getDarwinDefines(Builder, Opts);
+    getDarwinIPhoneOSDefines(Builder, Triple);
   }
 
 public:
@@ -1497,10 +1482,10 @@ public:
                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    DefineStd(Defines, "sparc", Opts);
-    Define(Defines, "__sparcv8");
-    Define(Defines, "__REGISTER_PREFIX__", "");
+                                MacroBuilder &Builder) const {
+    DefineStd(Builder, "sparc", Opts);
+    Builder.defineMacro("__sparcv8");
+    Builder.defineMacro("__REGISTER_PREFIX__", "");
   }
   virtual void getTargetBuiltins(const Builtin::Info *&Records,
                                  unsigned &NumRecords) const {
@@ -1630,18 +1615,18 @@ namespace {
     virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
     virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
     virtual void getTargetDefines(const LangOptions &Opts,
-                                  std::vector<char> &Defines) const {
-      Define(Defines, "__pic16");
-      Define(Defines, "rom", "__attribute__((address_space(1)))");
-      Define(Defines, "ram", "__attribute__((address_space(0)))");
-      Define(Defines, "_section(SectName)",
+                                MacroBuilder &Builder) const {
+      Builder.defineMacro("__pic16");
+      Builder.defineMacro("rom", "__attribute__((address_space(1)))");
+      Builder.defineMacro("ram", "__attribute__((address_space(0)))");
+      Builder.defineMacro("_section(SectName)",
              "__attribute__((section(SectName)))");
-      Define(Defines, "near",
+      Builder.defineMacro("near",
              "__attribute__((section(\"Address=NEAR\")))");
-      Define(Defines, "_address(Addr)",
+      Builder.defineMacro("_address(Addr)",
              "__attribute__((section(\"Address=\"#Addr)))");
-      Define(Defines, "_CONFIG(conf)", "asm(\"CONFIG \"#conf)");
-      Define(Defines, "_interrupt",
+      Builder.defineMacro("_CONFIG(conf)", "asm(\"CONFIG \"#conf)");
+      Builder.defineMacro("_interrupt",
              "__attribute__((section(\"interrupt=0x4\"))) \
              __attribute__((used))");
     }
@@ -1672,7 +1657,8 @@ namespace {
     MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
       TLSSupported = false;
       IntWidth = 16;
-      LongWidth = LongLongWidth = 32;
+      LongWidth = 32;
+      LongLongWidth = 64;
       PointerWidth = 16;
       IntAlign = 8;
       LongAlign = LongLongAlign = 8;
@@ -1686,9 +1672,9 @@ namespace {
       DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
    }
     virtual void getTargetDefines(const LangOptions &Opts,
-                                 std::vector<char> &Defines) const {
-      Define(Defines, "MSP430");
-      Define(Defines, "__MSP430__");
+                                  MacroBuilder &Builder) const {
+      Builder.defineMacro("MSP430");
+      Builder.defineMacro("__MSP430__");
       // FIXME: defines for different 'flavours' of MCU
     }
     virtual void getTargetBuiltins(const Builtin::Info *&Records,
@@ -1746,9 +1732,9 @@ namespace {
       "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
    }
     virtual void getTargetDefines(const LangOptions &Opts,
-                                 std::vector<char> &Defines) const {
-      Define(Defines, "__s390__");
-      Define(Defines, "__s390x__");
+                                  MacroBuilder &Builder) const {
+      Builder.defineMacro("__s390__");
+      Builder.defineMacro("__s390x__");
     }
     virtual void getTargetBuiltins(const Builtin::Info *&Records,
                                    unsigned &NumRecords) const {
@@ -1805,12 +1791,12 @@ namespace {
     }
 
     virtual void getTargetDefines(const LangOptions &Opts,
-                                  std::vector<char> &Defines) const {
-      DefineStd(Defines, "bfin", Opts);
-      DefineStd(Defines, "BFIN", Opts);
-      Define(Defines, "__ADSPBLACKFIN__");
+                                  MacroBuilder &Builder) const {
+      DefineStd(Builder, "bfin", Opts);
+      DefineStd(Builder, "BFIN", Opts);
+      Builder.defineMacro("__ADSPBLACKFIN__");
       // FIXME: This one is really dependent on -mcpu
-      Define(Defines, "__ADSPLPBLACKFIN__");
+      Builder.defineMacro("__ADSPLPBLACKFIN__");
       // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
     }
 
@@ -1906,10 +1892,10 @@ namespace {
     }
 
     virtual void getTargetDefines(const LangOptions &Opts,
-                                  std::vector<char> &Defines) const {
-      DefineStd(Defines, "tce", Opts);
-      Define(Defines, "__TCE__");
-      Define(Defines, "__TCE_V1__");
+                                  MacroBuilder &Builder) const {
+      DefineStd(Builder, "tce", Opts);
+      Builder.defineMacro("__TCE__");
+      Builder.defineMacro("__TCE_V1__");
     }
     virtual void getTargetBuiltins(const Builtin::Info *&Records,
                                    unsigned &NumRecords) const {}
@@ -1940,12 +1926,12 @@ public:
                         "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
   }
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const {
-    DefineStd(Defines, "mips", Opts);
-    Define(Defines, "_mips");
-    DefineStd(Defines, "MIPSEB", Opts);
-    Define(Defines, "_MIPSEB");
-    Define(Defines, "__REGISTER_PREFIX__", "");
+                                MacroBuilder &Builder) const {
+    DefineStd(Builder, "mips", Opts);
+    Builder.defineMacro("_mips");
+    DefineStd(Builder, "MIPSEB", Opts);
+    Builder.defineMacro("_MIPSEB");
+    Builder.defineMacro("__REGISTER_PREFIX__", "");
   }
   virtual void getTargetBuiltins(const Builtin::Info *&Records,
                                  unsigned &NumRecords) const {
@@ -2047,16 +2033,16 @@ public:
   }
 
   virtual void getTargetDefines(const LangOptions &Opts,
-                                std::vector<char> &Defines) const;
+                                MacroBuilder &Builder) const;
 };
 
 void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
-                                        std::vector<char> &Defines) const {
-  DefineStd(Defines, "mips", Opts);
-  Define(Defines, "_mips");
-  DefineStd(Defines, "MIPSEL", Opts);
-  Define(Defines, "_MIPSEL");
-  Define(Defines, "__REGISTER_PREFIX__", "");
+                                        MacroBuilder &Builder) const {
+  DefineStd(Builder, "mips", Opts);
+  Builder.defineMacro("_mips");
+  DefineStd(Builder, "MIPSEL", Opts);
+  Builder.defineMacro("_MIPSEL");
+  Builder.defineMacro("__REGISTER_PREFIX__", "");
 }
 } // end anonymous namespace.
 
@@ -2171,6 +2157,8 @@ static TargetInfo *AllocateTarget(const std::string &T) {
       return new DarwinX86_64TargetInfo(T);
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<X86_64TargetInfo>(T);
+    case llvm::Triple::DragonFly:
+      return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<X86_64TargetInfo>(T);
     case llvm::Triple::OpenBSD: