diff options
Diffstat (limited to 'lib/Basic/Targets.cpp')
| -rw-r--r-- | lib/Basic/Targets.cpp | 456 |
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: |
