InitPreprocessor.cpp revision 198092
1193326Sed//===--- InitPreprocessor.cpp - PP initialization code. ---------*- C++ -*-===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This file implements the clang::InitializePreprocessor function. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13249423Sdim 14249423Sdim#include "clang/Frontend/InitPreprocessor.h" 15193326Sed#include "clang/Basic/TargetInfo.h" 16193326Sed#include "clang/Lex/Preprocessor.h" 17193326Sed#include "llvm/ADT/StringExtras.h" 18193326Sed#include "llvm/ADT/STLExtras.h" 19193326Sed#include "llvm/System/Path.h" 20193326Sed 21193326Sednamespace clang { 22193326Sed 23193326Sed// Append a #define line to Buf for Macro. Macro should be of the form XXX, 24198092Srdivacky// in which case we emit "#define XXX 1" or "XXX=Y z W" in which case we emit 25198092Srdivacky// "#define XXX Y z W". To get a #define with no value, use "XXX=". 26198092Srdivackystatic void DefineBuiltinMacro(std::vector<char> &Buf, const char *Macro) { 27208600Srdivacky const char *Command = "#define "; 28193326Sed Buf.insert(Buf.end(), Command, Command+strlen(Command)); 29234353Sdim if (const char *Equal = strchr(Macro, '=')) { 30234353Sdim // Turn the = into ' '. 31234353Sdim Buf.insert(Buf.end(), Macro, Equal); 32234353Sdim Buf.push_back(' '); 33234353Sdim 34234353Sdim // Per GCC -D semantics, the macro ends at \n if it exists. 35234353Sdim const char *End = strpbrk(Equal, "\n\r"); 36234353Sdim if (End) { 37234353Sdim fprintf(stderr, "warning: macro '%s' contains embedded newline, text " 38234353Sdim "after the newline is ignored.\n", 39234353Sdim std::string(Macro, Equal).c_str()); 40234353Sdim } else { 41234353Sdim End = Equal+strlen(Equal); 42234353Sdim } 43234353Sdim 44234353Sdim Buf.insert(Buf.end(), Equal+1, End); 45234353Sdim } else { 46234353Sdim // Push "macroname 1". 47234353Sdim Buf.insert(Buf.end(), Macro, Macro+strlen(Macro)); 48234353Sdim Buf.push_back(' '); 49234353Sdim Buf.push_back('1'); 50234353Sdim } 51234353Sdim Buf.push_back('\n'); 52234353Sdim} 53234353Sdim 54234353Sdim// Append a #undef line to Buf for Macro. Macro should be of the form XXX 55234353Sdim// and we emit "#undef XXX". 56234353Sdimstatic void UndefineBuiltinMacro(std::vector<char> &Buf, const char *Macro) { 57234353Sdim // Push "macroname". 58234353Sdim const char *Command = "#undef "; 59234353Sdim Buf.insert(Buf.end(), Command, Command+strlen(Command)); 60234353Sdim Buf.insert(Buf.end(), Macro, Macro+strlen(Macro)); 61234353Sdim Buf.push_back('\n'); 62234353Sdim} 63234353Sdim 64234353Sdim/// Add the quoted name of an implicit include file. 65234353Sdimstatic void AddQuotedIncludePath(std::vector<char> &Buf, 66234353Sdim const std::string &File) { 67234353Sdim // Implicit include paths should be resolved relative to the current 68234353Sdim // working directory first, and then use the regular header search 69234353Sdim // mechanism. The proper way to handle this is to have the 70234353Sdim // predefines buffer located at the current working directory, but 71234353Sdim // it has not file entry. For now, workaround this by using an 72234353Sdim // absolute path if we find the file here, and otherwise letting 73234353Sdim // header search handle it. 74234353Sdim llvm::sys::Path Path(File); 75234353Sdim Path.makeAbsolute(); 76234353Sdim if (!Path.exists()) 77234353Sdim Path = File; 78234353Sdim 79234353Sdim // Escape double quotes etc. 80234353Sdim Buf.push_back('"'); 81234353Sdim std::string EscapedFile = Lexer::Stringify(Path.str()); 82234353Sdim Buf.insert(Buf.end(), EscapedFile.begin(), EscapedFile.end()); 83234353Sdim Buf.push_back('"'); 84234353Sdim} 85234353Sdim 86234353Sdim/// AddImplicitInclude - Add an implicit #include of the specified file to the 87234353Sdim/// predefines buffer. 88234353Sdimstatic void AddImplicitInclude(std::vector<char> &Buf, 89234353Sdim const std::string &File) { 90234353Sdim const char *Inc = "#include "; 91234353Sdim Buf.insert(Buf.end(), Inc, Inc+strlen(Inc)); 92234353Sdim AddQuotedIncludePath(Buf, File); 93234353Sdim Buf.push_back('\n'); 94234353Sdim} 95234353Sdim 96234353Sdimstatic void AddImplicitIncludeMacros(std::vector<char> &Buf, 97234353Sdim const std::string &File) { 98234353Sdim const char *Inc = "#__include_macros "; 99234353Sdim Buf.insert(Buf.end(), Inc, Inc+strlen(Inc)); 100239462Sdim AddQuotedIncludePath(Buf, File); 101234353Sdim Buf.push_back('\n'); 102234353Sdim // Marker token to stop the __include_macros fetch loop. 103234353Sdim const char *Marker = "##\n"; // ##? 104234353Sdim Buf.insert(Buf.end(), Marker, Marker+strlen(Marker)); 105234353Sdim} 106234353Sdim 107234353Sdim/// AddImplicitIncludePTH - Add an implicit #include using the original file 108234353Sdim/// used to generate a PTH cache. 109234353Sdimstatic void AddImplicitIncludePTH(std::vector<char> &Buf, Preprocessor &PP, 110234353Sdim const std::string& ImplicitIncludePTH) { 111234353Sdim PTHManager *P = PP.getPTHManager(); 112243830Sdim assert(P && "No PTHManager."); 113234353Sdim const char *OriginalFile = P->getOriginalSourceFile(); 114234353Sdim 115234353Sdim if (!OriginalFile) { 116234353Sdim assert(!ImplicitIncludePTH.empty()); 117234353Sdim fprintf(stderr, "error: PTH file '%s' does not designate an original " 118234353Sdim "source header file for -include-pth\n", 119234353Sdim ImplicitIncludePTH.c_str()); 120193326Sed exit (1); 121234353Sdim } 122193326Sed 123193326Sed AddImplicitInclude(Buf, OriginalFile); 124193326Sed} 125243830Sdim 126251662Sdim/// PickFP - This is used to pick a value based on the FP semantics of the 127243830Sdim/// specified FP model. 128234353Sdimtemplate <typename T> 129234353Sdimstatic T PickFP(const llvm::fltSemantics *Sem, T IEEESingleVal, 130249423Sdim T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal, 131249423Sdim T IEEEQuadVal) { 132249423Sdim if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEsingle) 133249423Sdim return IEEESingleVal; 134234353Sdim if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEdouble) 135234353Sdim return IEEEDoubleVal; 136234353Sdim if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::x87DoubleExtended) 137234353Sdim return X87DoubleExtendedVal; 138234353Sdim if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::PPCDoubleDouble) 139234353Sdim return PPCDoubleDoubleVal; 140234353Sdim assert(Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEquad); 141234353Sdim return IEEEQuadVal; 142234353Sdim} 143234353Sdim 144193326Sedstatic void DefineFloatMacros(std::vector<char> &Buf, const char *Prefix, 145249423Sdim const llvm::fltSemantics *Sem) { 146249423Sdim const char *DenormMin, *Epsilon, *Max, *Min; 147249423Sdim DenormMin = PickFP(Sem, "1.40129846e-45F", "4.9406564584124654e-324", 148249423Sdim "3.64519953188247460253e-4951L", 149234353Sdim "4.94065645841246544176568792868221e-324L", 150234353Sdim "6.47517511943802511092443895822764655e-4966L"); 151234353Sdim int Digits = PickFP(Sem, 6, 15, 18, 31, 33); 152208600Srdivacky Epsilon = PickFP(Sem, "1.19209290e-7F", "2.2204460492503131e-16", 153212904Sdim "1.08420217248550443401e-19L", 154212904Sdim "4.94065645841246544176568792868221e-324L", 155212904Sdim "1.92592994438723585305597794258492732e-34L"); 156212904Sdim int HasInifinity = 1, HasQuietNaN = 1; 157249423Sdim int MantissaDigits = PickFP(Sem, 24, 53, 64, 106, 113); 158249423Sdim int Min10Exp = PickFP(Sem, -37, -307, -4931, -291, -4931); 159249423Sdim int Max10Exp = PickFP(Sem, 38, 308, 4932, 308, 4932); 160249423Sdim int MinExp = PickFP(Sem, -125, -1021, -16381, -968, -16381); 161249423Sdim int MaxExp = PickFP(Sem, 128, 1024, 16384, 1024, 16384); 162212904Sdim Min = PickFP(Sem, "1.17549435e-38F", "2.2250738585072014e-308", 163249423Sdim "3.36210314311209350626e-4932L", 164249423Sdim "2.00416836000897277799610805135016e-292L", 165249423Sdim "3.36210314311209350626267781732175260e-4932L"); 166193326Sed Max = PickFP(Sem, "3.40282347e+38F", "1.7976931348623157e+308", 167203955Srdivacky "1.18973149535723176502e+4932L", 168198092Srdivacky "1.79769313486231580793728971405301e+308L", 169203955Srdivacky "1.18973149535723176508575932662800702e+4932L"); 170203955Srdivacky 171203955Srdivacky char MacroBuf[100]; 172203955Srdivacky sprintf(MacroBuf, "__%s_DENORM_MIN__=%s", Prefix, DenormMin); 173193326Sed DefineBuiltinMacro(Buf, MacroBuf); 174221345Sdim sprintf(MacroBuf, "__%s_DIG__=%d", Prefix, Digits); 175203955Srdivacky DefineBuiltinMacro(Buf, MacroBuf); 176208600Srdivacky sprintf(MacroBuf, "__%s_EPSILON__=%s", Prefix, Epsilon); 177221345Sdim DefineBuiltinMacro(Buf, MacroBuf); 178221345Sdim sprintf(MacroBuf, "__%s_HAS_INFINITY__=%d", Prefix, HasInifinity); 179221345Sdim DefineBuiltinMacro(Buf, MacroBuf); 180221345Sdim sprintf(MacroBuf, "__%s_HAS_QUIET_NAN__=%d", Prefix, HasQuietNaN); 181234353Sdim DefineBuiltinMacro(Buf, MacroBuf); 182203955Srdivacky sprintf(MacroBuf, "__%s_MANT_DIG__=%d", Prefix, MantissaDigits); 183239462Sdim DefineBuiltinMacro(Buf, MacroBuf); 184193326Sed sprintf(MacroBuf, "__%s_MAX_10_EXP__=%d", Prefix, Max10Exp); 185193326Sed DefineBuiltinMacro(Buf, MacroBuf); 186203955Srdivacky sprintf(MacroBuf, "__%s_MAX_EXP__=%d", Prefix, MaxExp); 187193326Sed DefineBuiltinMacro(Buf, MacroBuf); 188239462Sdim sprintf(MacroBuf, "__%s_MAX__=%s", Prefix, Max); 189239462Sdim DefineBuiltinMacro(Buf, MacroBuf); 190239462Sdim sprintf(MacroBuf, "__%s_MIN_10_EXP__=(%d)", Prefix, Min10Exp); 191224145Sdim DefineBuiltinMacro(Buf, MacroBuf); 192212904Sdim sprintf(MacroBuf, "__%s_MIN_EXP__=(%d)", Prefix, MinExp); 193212904Sdim DefineBuiltinMacro(Buf, MacroBuf); 194212904Sdim sprintf(MacroBuf, "__%s_MIN__=%s", Prefix, Min); 195193326Sed DefineBuiltinMacro(Buf, MacroBuf); 196249423Sdim sprintf(MacroBuf, "__%s_HAS_DENORM__=1", Prefix); 197198092Srdivacky DefineBuiltinMacro(Buf, MacroBuf); 198193326Sed} 199226633Sdim 200226633Sdim 201212904Sdim/// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro 202198092Srdivacky/// named MacroName with the max value for a type with width 'TypeWidth' a 203198092Srdivacky/// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL). 204198092Srdivackystatic void DefineTypeSize(const char *MacroName, unsigned TypeWidth, 205203955Srdivacky const char *ValSuffix, bool isSigned, 206203955Srdivacky std::vector<char> &Buf) { 207221345Sdim char MacroBuf[60]; 208221345Sdim long long MaxVal; 209221345Sdim if (isSigned) 210221345Sdim MaxVal = (1LL << (TypeWidth - 1)) - 1; 211203955Srdivacky else 212203955Srdivacky MaxVal = ~0LL >> (64-TypeWidth); 213221345Sdim 214221345Sdim // FIXME: Switch to using raw_ostream and avoid utostr(). 215234353Sdim sprintf(MacroBuf, "%s=%s%s", MacroName, llvm::utostr(MaxVal).c_str(), 216203955Srdivacky ValSuffix); 217203955Srdivacky DefineBuiltinMacro(Buf, MacroBuf); 218203955Srdivacky} 219203955Srdivacky 220221345Sdimstatic void DefineType(const char *MacroName, TargetInfo::IntType Ty, 221221345Sdim std::vector<char> &Buf) { 222234353Sdim char MacroBuf[60]; 223193326Sed sprintf(MacroBuf, "%s=%s", MacroName, TargetInfo::getTypeName(Ty)); 224193326Sed DefineBuiltinMacro(Buf, MacroBuf); 225203955Srdivacky} 226203955Srdivacky 227203955Srdivacky 228193326Sedstatic void InitializePredefinedMacros(const TargetInfo &TI, 229193326Sed const LangOptions &LangOpts, 230221345Sdim std::vector<char> &Buf) { 231221345Sdim char MacroBuf[60]; 232221345Sdim // Compiler version introspection macros. 233221345Sdim DefineBuiltinMacro(Buf, "__llvm__=1"); // LLVM Backend 234221345Sdim DefineBuiltinMacro(Buf, "__clang__=1"); // Clang Frontend 235234353Sdim 236243830Sdim // Currently claim to be compatible with GCC 4.2.1-5621. 237234353Sdim DefineBuiltinMacro(Buf, "__GNUC_MINOR__=2"); 238234353Sdim DefineBuiltinMacro(Buf, "__GNUC_PATCHLEVEL__=1"); 239205408Srdivacky DefineBuiltinMacro(Buf, "__GNUC__=4"); 240205408Srdivacky DefineBuiltinMacro(Buf, "__GXX_ABI_VERSION=1002"); 241234353Sdim DefineBuiltinMacro(Buf, "__VERSION__=\"4.2.1 Compatible Clang Compiler\""); 242203955Srdivacky 243234353Sdim 244203955Srdivacky // Initialize language-specific preprocessor defines. 245203955Srdivacky 246202879Srdivacky // These should all be defined in the preprocessor according to the 247202879Srdivacky // current language configuration. 248202879Srdivacky if (!LangOpts.Microsoft) 249226633Sdim DefineBuiltinMacro(Buf, "__STDC__=1"); 250202879Srdivacky if (LangOpts.AsmPreprocessor) 251203955Srdivacky DefineBuiltinMacro(Buf, "__ASSEMBLER__=1"); 252203955Srdivacky 253234353Sdim if (!LangOpts.CPlusPlus) { 254198092Srdivacky if (LangOpts.C99) 255198092Srdivacky DefineBuiltinMacro(Buf, "__STDC_VERSION__=199901L"); 256203955Srdivacky else if (!LangOpts.GNUMode && LangOpts.Digraphs) 257203955Srdivacky DefineBuiltinMacro(Buf, "__STDC_VERSION__=199409L"); 258234353Sdim } 259193326Sed 260193326Sed // Standard conforming mode? 261224145Sdim if (!LangOpts.GNUMode) 262224145Sdim DefineBuiltinMacro(Buf, "__STRICT_ANSI__=1"); 263224145Sdim 264224145Sdim if (LangOpts.CPlusPlus0x) 265198092Srdivacky DefineBuiltinMacro(Buf, "__GXX_EXPERIMENTAL_CXX0X__"); 266198092Srdivacky 267198092Srdivacky if (LangOpts.Freestanding) 268198092Srdivacky DefineBuiltinMacro(Buf, "__STDC_HOSTED__=0"); 269224145Sdim else 270198092Srdivacky DefineBuiltinMacro(Buf, "__STDC_HOSTED__=1"); 271198092Srdivacky 272198092Srdivacky if (LangOpts.ObjC1) { 273198092Srdivacky DefineBuiltinMacro(Buf, "__OBJC__=1"); 274212904Sdim if (LangOpts.ObjCNonFragileABI) { 275212904Sdim DefineBuiltinMacro(Buf, "__OBJC2__=1"); 276218893Sdim DefineBuiltinMacro(Buf, "OBJC_ZEROCOST_EXCEPTIONS=1"); 277218893Sdim } 278239462Sdim 279226633Sdim if (LangOpts.getGCMode() != LangOptions::NonGC) 280224145Sdim DefineBuiltinMacro(Buf, "__OBJC_GC__=1"); 281210299Sed 282198092Srdivacky if (LangOpts.NeXTRuntime) 283198092Srdivacky DefineBuiltinMacro(Buf, "__NEXT_RUNTIME__=1"); 284199482Srdivacky } 285212904Sdim 286212904Sdim // darwin_constant_cfstrings controls this. This is also dependent 287212904Sdim // on other things like the runtime I believe. This is set even for C code. 288199482Srdivacky DefineBuiltinMacro(Buf, "__CONSTANT_CFSTRINGS__=1"); 289208600Srdivacky 290210299Sed if (LangOpts.ObjC2) 291210299Sed DefineBuiltinMacro(Buf, "OBJC_NEW_PROPERTIES"); 292210299Sed 293234353Sdim if (LangOpts.PascalStrings) 294234353Sdim DefineBuiltinMacro(Buf, "__PASCAL_STRINGS__"); 295210299Sed 296208600Srdivacky if (LangOpts.Blocks) { 297218893Sdim DefineBuiltinMacro(Buf, "__block=__attribute__((__blocks__(byref)))"); 298218893Sdim DefineBuiltinMacro(Buf, "__BLOCKS__=1"); 299218893Sdim } 300218893Sdim 301218893Sdim if (LangOpts.Exceptions) 302218893Sdim DefineBuiltinMacro(Buf, "__EXCEPTIONS=1"); 303218893Sdim 304239462Sdim if (LangOpts.CPlusPlus) { 305239462Sdim DefineBuiltinMacro(Buf, "__DEPRECATED=1"); 306239462Sdim DefineBuiltinMacro(Buf, "__GNUG__=4"); 307239462Sdim DefineBuiltinMacro(Buf, "__GXX_WEAK__=1"); 308239462Sdim if (LangOpts.GNUMode) 309243830Sdim DefineBuiltinMacro(Buf, "__cplusplus=1"); 310243830Sdim else 311243830Sdim // C++ [cpp.predefined]p1: 312243830Sdim // The name_ _cplusplusis defined to the value199711Lwhen compiling a 313199482Srdivacky // C++ translation unit. 314207619Srdivacky DefineBuiltinMacro(Buf, "__cplusplus=199711L"); 315207619Srdivacky DefineBuiltinMacro(Buf, "__private_extern__=extern"); 316199482Srdivacky // Ugly hack to work with GNU libstdc++. 317207619Srdivacky DefineBuiltinMacro(Buf, "_GNU_SOURCE=1"); 318207619Srdivacky } 319207619Srdivacky 320207619Srdivacky // Filter out some microsoft extensions when trying to parse in ms-compat 321207619Srdivacky // mode. 322207619Srdivacky if (LangOpts.Microsoft) { 323207619Srdivacky DefineBuiltinMacro(Buf, "__int8=__INT8_TYPE__"); 324193326Sed DefineBuiltinMacro(Buf, "__int16=__INT16_TYPE__"); 325226633Sdim DefineBuiltinMacro(Buf, "__int32=__INT32_TYPE__"); 326226633Sdim DefineBuiltinMacro(Buf, "__int64=__INT64_TYPE__"); 327226633Sdim } 328234353Sdim 329226633Sdim if (LangOpts.Optimize) 330226633Sdim DefineBuiltinMacro(Buf, "__OPTIMIZE__=1"); 331199482Srdivacky if (LangOpts.OptimizeSize) 332234353Sdim DefineBuiltinMacro(Buf, "__OPTIMIZE_SIZE__=1"); 333234353Sdim 334234353Sdim // Initialize target-specific preprocessor defines. 335243830Sdim 336251662Sdim // Define type sizing macros based on the target properties. 337243830Sdim assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far"); 338198092Srdivacky DefineBuiltinMacro(Buf, "__CHAR_BIT__=8"); 339221345Sdim 340221345Sdim unsigned IntMaxWidth; 341207619Srdivacky const char *IntMaxSuffix; 342207619Srdivacky if (TI.getIntMaxType() == TargetInfo::SignedLongLong) { 343243830Sdim IntMaxWidth = TI.getLongLongWidth(); 344234353Sdim IntMaxSuffix = "LL"; 345201361Srdivacky } else if (TI.getIntMaxType() == TargetInfo::SignedLong) { 346201361Srdivacky IntMaxWidth = TI.getLongWidth(); 347203955Srdivacky IntMaxSuffix = "L"; 348203955Srdivacky } else { 349198092Srdivacky assert(TI.getIntMaxType() == TargetInfo::SignedInt); 350193326Sed IntMaxWidth = TI.getIntWidth(); 351193326Sed IntMaxSuffix = ""; 352198092Srdivacky } 353208600Srdivacky 354193326Sed DefineTypeSize("__SCHAR_MAX__", TI.getCharWidth(), "", true, Buf); 355249423Sdim DefineTypeSize("__SHRT_MAX__", TI.getShortWidth(), "", true, Buf); 356198092Srdivacky DefineTypeSize("__INT_MAX__", TI.getIntWidth(), "", true, Buf); 357198092Srdivacky DefineTypeSize("__LONG_MAX__", TI.getLongWidth(), "L", true, Buf); 358198092Srdivacky DefineTypeSize("__LONG_LONG_MAX__", TI.getLongLongWidth(), "LL", true, Buf); 359198092Srdivacky DefineTypeSize("__WCHAR_MAX__", TI.getWCharWidth(), "", true, Buf); 360198092Srdivacky DefineTypeSize("__INTMAX_MAX__", IntMaxWidth, IntMaxSuffix, true, Buf); 361198092Srdivacky 362249423Sdim DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Buf); 363249423Sdim DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Buf); 364249423Sdim DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Buf); 365249423Sdim DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Buf); 366218893Sdim DefineType("__SIZE_TYPE__", TI.getSizeType(), Buf); 367218893Sdim DefineType("__WCHAR_TYPE__", TI.getWCharType(), Buf); 368218893Sdim // FIXME: TargetInfo hookize __WINT_TYPE__. 369218893Sdim DefineBuiltinMacro(Buf, "__WINT_TYPE__=int"); 370218893Sdim 371218893Sdim DefineFloatMacros(Buf, "FLT", &TI.getFloatFormat()); 372224145Sdim DefineFloatMacros(Buf, "DBL", &TI.getDoubleFormat()); 373224145Sdim DefineFloatMacros(Buf, "LDBL", &TI.getLongDoubleFormat()); 374198092Srdivacky 375198092Srdivacky // Define a __POINTER_WIDTH__ macro for stdint.h. 376198092Srdivacky sprintf(MacroBuf, "__POINTER_WIDTH__=%d", (int)TI.getPointerWidth(0)); 377198092Srdivacky DefineBuiltinMacro(Buf, MacroBuf); 378208600Srdivacky 379198092Srdivacky if (!LangOpts.CharIsSigned) 380234353Sdim DefineBuiltinMacro(Buf, "__CHAR_UNSIGNED__"); 381234353Sdim 382193326Sed // Define fixed-sized integer types for stdint.h 383226633Sdim assert(TI.getCharWidth() == 8 && "unsupported target types"); 384226633Sdim assert(TI.getShortWidth() == 16 && "unsupported target types"); 385212904Sdim DefineBuiltinMacro(Buf, "__INT8_TYPE__=char"); 386249423Sdim DefineBuiltinMacro(Buf, "__INT16_TYPE__=short"); 387193326Sed 388193326Sed if (TI.getIntWidth() == 32) 389218893Sdim DefineBuiltinMacro(Buf, "__INT32_TYPE__=int"); 390234353Sdim else { 391234353Sdim assert(TI.getLongLongWidth() == 32 && "unsupported target types"); 392234353Sdim DefineBuiltinMacro(Buf, "__INT32_TYPE__=long long"); 393234353Sdim } 394218893Sdim 395218893Sdim // 16-bit targets doesn't necessarily have a 64-bit type. 396218893Sdim if (TI.getLongLongWidth() == 64) 397249423Sdim DefineType("__INT64_TYPE__", TI.getInt64Type(), Buf); 398249423Sdim 399218893Sdim // Add __builtin_va_list typedef. 400218893Sdim { 401218893Sdim const char *VAList = TI.getVAListDeclaration(); 402218893Sdim Buf.insert(Buf.end(), VAList, VAList+strlen(VAList)); 403208600Srdivacky Buf.push_back('\n'); 404198092Srdivacky } 405234353Sdim 406198092Srdivacky if (const char *Prefix = TI.getUserLabelPrefix()) { 407249423Sdim sprintf(MacroBuf, "__USER_LABEL_PREFIX__=%s", Prefix); 408249423Sdim DefineBuiltinMacro(Buf, MacroBuf); 409249423Sdim } 410198092Srdivacky 411198092Srdivacky // Build configuration options. FIXME: these should be controlled by 412234353Sdim // command line options or something. 413234353Sdim DefineBuiltinMacro(Buf, "__FINITE_MATH_ONLY__=0"); 414234353Sdim 415234353Sdim if (LangOpts.GNUInline) 416249423Sdim DefineBuiltinMacro(Buf, "__GNUC_GNU_INLINE__=1"); 417249423Sdim else 418249423Sdim DefineBuiltinMacro(Buf, "__GNUC_STDC_INLINE__=1"); 419249423Sdim 420234353Sdim if (LangOpts.NoInline) 421234353Sdim DefineBuiltinMacro(Buf, "__NO_INLINE__=1"); 422234353Sdim 423234353Sdim if (unsigned PICLevel = LangOpts.PICLevel) { 424218893Sdim sprintf(MacroBuf, "__PIC__=%d", PICLevel); 425195341Sed DefineBuiltinMacro(Buf, MacroBuf); 426234353Sdim 427195341Sed sprintf(MacroBuf, "__pic__=%d", PICLevel); 428239462Sdim DefineBuiltinMacro(Buf, MacroBuf); 429234353Sdim } 430234353Sdim 431249423Sdim // Macros to control C99 numerics and <float.h> 432249423Sdim DefineBuiltinMacro(Buf, "__FLT_EVAL_METHOD__=0"); 433249423Sdim DefineBuiltinMacro(Buf, "__FLT_RADIX__=2"); 434195341Sed sprintf(MacroBuf, "__DECIMAL_DIG__=%d", 435195341Sed PickFP(&TI.getLongDoubleFormat(), -1/*FIXME*/, 17, 21, 33, 36)); 436239462Sdim DefineBuiltinMacro(Buf, MacroBuf); 437239462Sdim 438239462Sdim if (LangOpts.getStackProtectorMode() == LangOptions::SSPOn) 439239462Sdim DefineBuiltinMacro(Buf, "__SSP__=1"); 440239462Sdim else if (LangOpts.getStackProtectorMode() == LangOptions::SSPReq) 441239462Sdim DefineBuiltinMacro(Buf, "__SSP_ALL__=2"); 442239462Sdim 443239462Sdim // Get other target #defines. 444239462Sdim TI.getTargetDefines(LangOpts, Buf); 445239462Sdim} 446239462Sdim 447239462Sdim/// InitializePreprocessor - Initialize the preprocessor getting it and the 448239462Sdim/// environment ready to process a single file. This returns true on error. 449239462Sdim/// 450239462Sdimbool InitializePreprocessor(Preprocessor &PP, 451249423Sdim const PreprocessorInitOptions& InitOpts) { 452249423Sdim std::vector<char> PredefineBuffer; 453249423Sdim 454249423Sdim const char *LineDirective = "# 1 \"<built-in>\" 3\n"; 455239462Sdim PredefineBuffer.insert(PredefineBuffer.end(), 456239462Sdim LineDirective, LineDirective+strlen(LineDirective)); 457218893Sdim 458193326Sed // Install things like __POWERPC__, __GNUC__, etc into the macro table. 459234353Sdim InitializePredefinedMacros(PP.getTargetInfo(), PP.getLangOptions(), 460193326Sed PredefineBuffer); 461255321Stheraven 462255321Stheraven // Add on the predefines from the driver. Wrap in a #line directive to report 463239462Sdim // that they come from the command line. 464234353Sdim LineDirective = "# 1 \"<command line>\" 1\n"; 465234353Sdim PredefineBuffer.insert(PredefineBuffer.end(), 466255321Stheraven LineDirective, LineDirective+strlen(LineDirective)); 467255321Stheraven 468255321Stheraven // Process #define's and #undef's in the order they are given. 469244640Sandrew for (PreprocessorInitOptions::macro_iterator I = InitOpts.macro_begin(), 470249423Sdim E = InitOpts.macro_end(); I != E; ++I) { 471249423Sdim if (I->second) // isUndef 472249423Sdim UndefineBuiltinMacro(PredefineBuffer, I->first.c_str()); 473193326Sed else 474193326Sed DefineBuiltinMacro(PredefineBuffer, I->first.c_str()); 475218893Sdim } 476218893Sdim 477234353Sdim // If -imacros are specified, include them now. These are processed before 478218893Sdim // any -include directives. 479239462Sdim for (PreprocessorInitOptions::imacro_iterator I = InitOpts.imacro_begin(), 480234353Sdim E = InitOpts.imacro_end(); I != E; ++I) 481234353Sdim AddImplicitIncludeMacros(PredefineBuffer, *I); 482251662Sdim 483251662Sdim // Process -include directives. 484251662Sdim for (PreprocessorInitOptions::include_iterator I = InitOpts.include_begin(), 485251662Sdim E = InitOpts.include_end(); I != E; ++I) { 486251662Sdim if (I->second) // isPTH 487249423Sdim AddImplicitIncludePTH(PredefineBuffer, PP, I->first); 488249423Sdim else 489249423Sdim AddImplicitInclude(PredefineBuffer, I->first); 490218893Sdim } 491218893Sdim 492234353Sdim // Null terminate PredefinedBuffer and add it. 493210299Sed PredefineBuffer.push_back(0); 494234353Sdim PP.setPredefines(&PredefineBuffer[0]); 495210299Sed 496249423Sdim // Once we've read this, we're done. 497249423Sdim return false; 498249423Sdim} 499210299Sed 500210299Sed} // namespace clang 501218893Sdim