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

Use MacroBuilder for TargetDefines instead of std::vector. 

llvm-svn: 93058
This commit is contained in:
Benjamin Kramer 2010-01-09 17:55:51 +00:00
parent 3f6323dea5
commit 2d6fda3205
3 changed files with 220 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
clang/include/clang/Basic/TargetInfo.h
View File

@ -30,6 +30,7 @@ class StringRef;
namespace clang {
class Diagnostic;
class LangOptions;
class MacroBuilder;
class SourceLocation;
class SourceManager;
class TargetOptions;
@ -209,7 +210,7 @@ public:
/// getTargetDefines - Appends the target-specific #define values for this
/// target set to the specified buffer.
virtual void getTargetDefines(const LangOptions &Opts,
std::vector<char> &DefineBuffer) const = 0;
MacroBuilder &Builder) const = 0;
/// getTargetBuiltins - Return information about target-specific builtins for

450
clang/lib/Basic/Targets.cpp
View File

@ -18,10 +18,10 @@
#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"
@ -32,37 +32,23 @@ 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 +60,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 +115,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 +138,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 +147,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 +177,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 +196,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 +208,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 +226,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 +247,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 +267,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 +286,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 +305,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 +327,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 +344,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 +365,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 +403,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 +447,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 +669,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 +815,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 +986,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 +1006,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 +1024,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 +1047,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 +1103,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 +1119,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 +1137,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 +1329,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 +1459,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 +1481,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 +1614,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))");
}
@ -1686,9 +1670,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 +1730,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 +1789,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 +1890,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 +1924,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 +2031,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.

4
clang/lib/Frontend/InitPreprocessor.cpp
View File

@ -410,9 +410,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
Builder.defineMacro("__SSP_ALL__", "2");
// Get other target #defines.
std::vector<char> Buf;
TI.getTargetDefines(LangOpts, Buf);
Builder.append(llvm::StringRef(&Buf[0], Buf.size()));
TI.getTargetDefines(LangOpts, Builder);
}
// Initialize the remapping of files to alternative contents, e.g.,