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//===----------------------------------------------------------------------===// 13193326Sed 14199482Srdivacky#include "clang/Frontend/Utils.h" 15252723Sdim#include "clang/Basic/FileManager.h" 16202879Srdivacky#include "clang/Basic/MacroBuilder.h" 17252723Sdim#include "clang/Basic/SourceManager.h" 18193326Sed#include "clang/Basic/TargetInfo.h" 19252723Sdim#include "clang/Basic/Version.h" 20200583Srdivacky#include "clang/Frontend/FrontendDiagnostic.h" 21202379Srdivacky#include "clang/Frontend/FrontendOptions.h" 22235633Sdim#include "clang/Lex/HeaderSearch.h" 23193326Sed#include "clang/Lex/Preprocessor.h" 24245431Sdim#include "clang/Lex/PreprocessorOptions.h" 25245431Sdim#include "clang/Serialization/ASTReader.h" 26202379Srdivacky#include "llvm/ADT/APFloat.h" 27218893Sdim#include "llvm/Support/FileSystem.h" 28200583Srdivacky#include "llvm/Support/MemoryBuffer.h" 29218893Sdim#include "llvm/Support/Path.h" 30198893Srdivackyusing namespace clang; 31193326Sed 32263509Sdimstatic bool MacroBodyEndsInBackslash(StringRef MacroBody) { 33263509Sdim while (!MacroBody.empty() && isWhitespace(MacroBody.back())) 34263509Sdim MacroBody = MacroBody.drop_back(); 35263509Sdim return !MacroBody.empty() && MacroBody.back() == '\\'; 36263509Sdim} 37263509Sdim 38193326Sed// Append a #define line to Buf for Macro. Macro should be of the form XXX, 39193326Sed// in which case we emit "#define XXX 1" or "XXX=Y z W" in which case we emit 40193326Sed// "#define XXX Y z W". To get a #define with no value, use "XXX=". 41226890Sdimstatic void DefineBuiltinMacro(MacroBuilder &Builder, StringRef Macro, 42226890Sdim DiagnosticsEngine &Diags) { 43226890Sdim std::pair<StringRef, StringRef> MacroPair = Macro.split('='); 44226890Sdim StringRef MacroName = MacroPair.first; 45226890Sdim StringRef MacroBody = MacroPair.second; 46202379Srdivacky if (MacroName.size() != Macro.size()) { 47193326Sed // Per GCC -D semantics, the macro ends at \n if it exists. 48226890Sdim StringRef::size_type End = MacroBody.find_first_of("\n\r"); 49226890Sdim if (End != StringRef::npos) 50202379Srdivacky Diags.Report(diag::warn_fe_macro_contains_embedded_newline) 51202379Srdivacky << MacroName; 52263509Sdim MacroBody = MacroBody.substr(0, End); 53263509Sdim // We handle macro bodies which end in a backslash by appending an extra 54263509Sdim // backslash+newline. This makes sure we don't accidentally treat the 55263509Sdim // backslash as a line continuation marker. 56263509Sdim if (MacroBodyEndsInBackslash(MacroBody)) 57263509Sdim Builder.defineMacro(MacroName, Twine(MacroBody) + "\\\n"); 58263509Sdim else 59263509Sdim Builder.defineMacro(MacroName, MacroBody); 60193326Sed } else { 61193326Sed // Push "macroname 1". 62202379Srdivacky Builder.defineMacro(Macro); 63193326Sed } 64193326Sed} 65193326Sed 66245431Sdim/// AddImplicitInclude - Add an implicit \#include of the specified file to the 67193326Sed/// predefines buffer. 68226890Sdimstatic void AddImplicitInclude(MacroBuilder &Builder, StringRef File, 69219077Sdim FileManager &FileMgr) { 70235633Sdim Builder.append(Twine("#include \"") + 71235633Sdim HeaderSearch::NormalizeDashIncludePath(File, FileMgr) + "\""); 72193326Sed} 73193326Sed 74202379Srdivackystatic void AddImplicitIncludeMacros(MacroBuilder &Builder, 75226890Sdim StringRef File, 76219077Sdim FileManager &FileMgr) { 77235633Sdim Builder.append(Twine("#__include_macros \"") + 78235633Sdim HeaderSearch::NormalizeDashIncludePath(File, FileMgr) + "\""); 79193326Sed // Marker token to stop the __include_macros fetch loop. 80202379Srdivacky Builder.append("##"); // ##? 81193326Sed} 82193326Sed 83245431Sdim/// AddImplicitIncludePTH - Add an implicit \#include using the original file 84245431Sdim/// used to generate a PTH cache. 85202379Srdivackystatic void AddImplicitIncludePTH(MacroBuilder &Builder, Preprocessor &PP, 86226890Sdim StringRef ImplicitIncludePTH) { 87193326Sed PTHManager *P = PP.getPTHManager(); 88210299Sed // Null check 'P' in the corner case where it couldn't be created. 89210299Sed const char *OriginalFile = P ? P->getOriginalSourceFile() : 0; 90198092Srdivacky 91193326Sed if (!OriginalFile) { 92200583Srdivacky PP.getDiagnostics().Report(diag::err_fe_pth_file_has_no_source_header) 93200583Srdivacky << ImplicitIncludePTH; 94200583Srdivacky return; 95193326Sed } 96198092Srdivacky 97219077Sdim AddImplicitInclude(Builder, OriginalFile, PP.getFileManager()); 98193326Sed} 99193326Sed 100245431Sdim/// \brief Add an implicit \#include using the original file used to generate 101245431Sdim/// a PCH file. 102245431Sdimstatic void AddImplicitIncludePCH(MacroBuilder &Builder, Preprocessor &PP, 103245431Sdim StringRef ImplicitIncludePCH) { 104245431Sdim std::string OriginalFile = 105245431Sdim ASTReader::getOriginalSourceFile(ImplicitIncludePCH, PP.getFileManager(), 106245431Sdim PP.getDiagnostics()); 107245431Sdim if (OriginalFile.empty()) 108245431Sdim return; 109245431Sdim 110245431Sdim AddImplicitInclude(Builder, OriginalFile, PP.getFileManager()); 111245431Sdim} 112245431Sdim 113193326Sed/// PickFP - This is used to pick a value based on the FP semantics of the 114193326Sed/// specified FP model. 115193326Sedtemplate <typename T> 116193326Sedstatic T PickFP(const llvm::fltSemantics *Sem, T IEEESingleVal, 117193326Sed T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal, 118193326Sed T IEEEQuadVal) { 119193401Sed if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEsingle) 120193326Sed return IEEESingleVal; 121193401Sed if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEdouble) 122193326Sed return IEEEDoubleVal; 123193401Sed if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::x87DoubleExtended) 124193326Sed return X87DoubleExtendedVal; 125193401Sed if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::PPCDoubleDouble) 126193326Sed return PPCDoubleDoubleVal; 127193401Sed assert(Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEquad); 128193326Sed return IEEEQuadVal; 129193326Sed} 130193326Sed 131226890Sdimstatic void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix, 132245431Sdim const llvm::fltSemantics *Sem, StringRef Ext) { 133193326Sed const char *DenormMin, *Epsilon, *Max, *Min; 134245431Sdim DenormMin = PickFP(Sem, "1.40129846e-45", "4.9406564584124654e-324", 135245431Sdim "3.64519953188247460253e-4951", 136245431Sdim "4.94065645841246544176568792868221e-324", 137245431Sdim "6.47517511943802511092443895822764655e-4966"); 138193326Sed int Digits = PickFP(Sem, 6, 15, 18, 31, 33); 139245431Sdim Epsilon = PickFP(Sem, "1.19209290e-7", "2.2204460492503131e-16", 140245431Sdim "1.08420217248550443401e-19", 141245431Sdim "4.94065645841246544176568792868221e-324", 142245431Sdim "1.92592994438723585305597794258492732e-34"); 143193326Sed int MantissaDigits = PickFP(Sem, 24, 53, 64, 106, 113); 144193326Sed int Min10Exp = PickFP(Sem, -37, -307, -4931, -291, -4931); 145193326Sed int Max10Exp = PickFP(Sem, 38, 308, 4932, 308, 4932); 146193326Sed int MinExp = PickFP(Sem, -125, -1021, -16381, -968, -16381); 147193326Sed int MaxExp = PickFP(Sem, 128, 1024, 16384, 1024, 16384); 148245431Sdim Min = PickFP(Sem, "1.17549435e-38", "2.2250738585072014e-308", 149245431Sdim "3.36210314311209350626e-4932", 150245431Sdim "2.00416836000897277799610805135016e-292", 151245431Sdim "3.36210314311209350626267781732175260e-4932"); 152245431Sdim Max = PickFP(Sem, "3.40282347e+38", "1.7976931348623157e+308", 153245431Sdim "1.18973149535723176502e+4932", 154245431Sdim "1.79769313486231580793728971405301e+308", 155245431Sdim "1.18973149535723176508575932662800702e+4932"); 156198092Srdivacky 157235633Sdim SmallString<32> DefPrefix; 158202879Srdivacky DefPrefix = "__"; 159202879Srdivacky DefPrefix += Prefix; 160202879Srdivacky DefPrefix += "_"; 161202379Srdivacky 162245431Sdim Builder.defineMacro(DefPrefix + "DENORM_MIN__", Twine(DenormMin)+Ext); 163202379Srdivacky Builder.defineMacro(DefPrefix + "HAS_DENORM__"); 164226890Sdim Builder.defineMacro(DefPrefix + "DIG__", Twine(Digits)); 165245431Sdim Builder.defineMacro(DefPrefix + "EPSILON__", Twine(Epsilon)+Ext); 166202379Srdivacky Builder.defineMacro(DefPrefix + "HAS_INFINITY__"); 167202379Srdivacky Builder.defineMacro(DefPrefix + "HAS_QUIET_NAN__"); 168226890Sdim Builder.defineMacro(DefPrefix + "MANT_DIG__", Twine(MantissaDigits)); 169202379Srdivacky 170226890Sdim Builder.defineMacro(DefPrefix + "MAX_10_EXP__", Twine(Max10Exp)); 171226890Sdim Builder.defineMacro(DefPrefix + "MAX_EXP__", Twine(MaxExp)); 172245431Sdim Builder.defineMacro(DefPrefix + "MAX__", Twine(Max)+Ext); 173202379Srdivacky 174226890Sdim Builder.defineMacro(DefPrefix + "MIN_10_EXP__","("+Twine(Min10Exp)+")"); 175226890Sdim Builder.defineMacro(DefPrefix + "MIN_EXP__", "("+Twine(MinExp)+")"); 176245431Sdim Builder.defineMacro(DefPrefix + "MIN__", Twine(Min)+Ext); 177193326Sed} 178193326Sed 179193326Sed 180193326Sed/// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro 181193326Sed/// named MacroName with the max value for a type with width 'TypeWidth' a 182193326Sed/// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL). 183226890Sdimstatic void DefineTypeSize(StringRef MacroName, unsigned TypeWidth, 184226890Sdim StringRef ValSuffix, bool isSigned, 185219077Sdim MacroBuilder &Builder) { 186219077Sdim llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth) 187219077Sdim : llvm::APInt::getMaxValue(TypeWidth); 188219077Sdim Builder.defineMacro(MacroName, MaxVal.toString(10, isSigned) + ValSuffix); 189193326Sed} 190193326Sed 191199482Srdivacky/// DefineTypeSize - An overloaded helper that uses TargetInfo to determine 192199482Srdivacky/// the width, suffix, and signedness of the given type 193226890Sdimstatic void DefineTypeSize(StringRef MacroName, TargetInfo::IntType Ty, 194202379Srdivacky const TargetInfo &TI, MacroBuilder &Builder) { 195199482Srdivacky DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty), 196202379Srdivacky TI.isTypeSigned(Ty), Builder); 197199482Srdivacky} 198199482Srdivacky 199226890Sdimstatic void DefineType(const Twine &MacroName, TargetInfo::IntType Ty, 200202379Srdivacky MacroBuilder &Builder) { 201202379Srdivacky Builder.defineMacro(MacroName, TargetInfo::getTypeName(Ty)); 202193326Sed} 203193326Sed 204226890Sdimstatic void DefineTypeWidth(StringRef MacroName, TargetInfo::IntType Ty, 205202379Srdivacky const TargetInfo &TI, MacroBuilder &Builder) { 206226890Sdim Builder.defineMacro(MacroName, Twine(TI.getTypeWidth(Ty))); 207199512Srdivacky} 208199512Srdivacky 209226890Sdimstatic void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth, 210210299Sed const TargetInfo &TI, MacroBuilder &Builder) { 211210299Sed Builder.defineMacro(MacroName, 212226890Sdim Twine(BitWidth / TI.getCharWidth())); 213210299Sed} 214210299Sed 215199482Srdivackystatic void DefineExactWidthIntType(TargetInfo::IntType Ty, 216202379Srdivacky const TargetInfo &TI, MacroBuilder &Builder) { 217199482Srdivacky int TypeWidth = TI.getTypeWidth(Ty); 218210299Sed 219210299Sed // Use the target specified int64 type, when appropriate, so that [u]int64_t 220210299Sed // ends up being defined in terms of the correct type. 221210299Sed if (TypeWidth == 64) 222210299Sed Ty = TI.getInt64Type(); 223210299Sed 224226890Sdim DefineType("__INT" + Twine(TypeWidth) + "_TYPE__", Ty, Builder); 225193326Sed 226226890Sdim StringRef ConstSuffix(TargetInfo::getTypeConstantSuffix(Ty)); 227202379Srdivacky if (!ConstSuffix.empty()) 228226890Sdim Builder.defineMacro("__INT" + Twine(TypeWidth) + "_C_SUFFIX__", 229202379Srdivacky ConstSuffix); 230199482Srdivacky} 231199482Srdivacky 232235633Sdim/// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with 233235633Sdim/// the specified properties. 234235633Sdimstatic const char *getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign, 235235633Sdim unsigned InlineWidth) { 236235633Sdim // Fully-aligned, power-of-2 sizes no larger than the inline 237235633Sdim // width will be inlined as lock-free operations. 238235633Sdim if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 && 239235633Sdim TypeWidth <= InlineWidth) 240235633Sdim return "2"; // "always lock free" 241235633Sdim // We cannot be certain what operations the lib calls might be 242235633Sdim // able to implement as lock-free on future processors. 243235633Sdim return "1"; // "sometimes lock free" 244235633Sdim} 245235633Sdim 246224145Sdim/// \brief Add definitions required for a smooth interaction between 247224145Sdim/// Objective-C++ automated reference counting and libstdc++ (4.2). 248224145Sdimstatic void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts, 249224145Sdim MacroBuilder &Builder) { 250224145Sdim Builder.defineMacro("_GLIBCXX_PREDEFINED_OBJC_ARC_IS_SCALAR"); 251224145Sdim 252224145Sdim std::string Result; 253224145Sdim { 254224145Sdim // Provide specializations for the __is_scalar type trait so that 255224145Sdim // lifetime-qualified objects are not considered "scalar" types, which 256224145Sdim // libstdc++ uses as an indicator of the presence of trivial copy, assign, 257224145Sdim // default-construct, and destruct semantics (none of which hold for 258224145Sdim // lifetime-qualified objects in ARC). 259224145Sdim llvm::raw_string_ostream Out(Result); 260224145Sdim 261224145Sdim Out << "namespace std {\n" 262224145Sdim << "\n" 263224145Sdim << "struct __true_type;\n" 264224145Sdim << "struct __false_type;\n" 265224145Sdim << "\n"; 266224145Sdim 267224145Sdim Out << "template<typename _Tp> struct __is_scalar;\n" 268224145Sdim << "\n"; 269224145Sdim 270224145Sdim Out << "template<typename _Tp>\n" 271224145Sdim << "struct __is_scalar<__attribute__((objc_ownership(strong))) _Tp> {\n" 272224145Sdim << " enum { __value = 0 };\n" 273224145Sdim << " typedef __false_type __type;\n" 274224145Sdim << "};\n" 275224145Sdim << "\n"; 276224145Sdim 277245431Sdim if (LangOpts.ObjCARCWeak) { 278224145Sdim Out << "template<typename _Tp>\n" 279224145Sdim << "struct __is_scalar<__attribute__((objc_ownership(weak))) _Tp> {\n" 280224145Sdim << " enum { __value = 0 };\n" 281224145Sdim << " typedef __false_type __type;\n" 282224145Sdim << "};\n" 283224145Sdim << "\n"; 284224145Sdim } 285224145Sdim 286224145Sdim Out << "template<typename _Tp>\n" 287224145Sdim << "struct __is_scalar<__attribute__((objc_ownership(autoreleasing)))" 288224145Sdim << " _Tp> {\n" 289224145Sdim << " enum { __value = 0 };\n" 290224145Sdim << " typedef __false_type __type;\n" 291224145Sdim << "};\n" 292224145Sdim << "\n"; 293224145Sdim 294224145Sdim Out << "}\n"; 295224145Sdim } 296224145Sdim Builder.append(Result); 297224145Sdim} 298224145Sdim 299223017Sdimstatic void InitializeStandardPredefinedMacros(const TargetInfo &TI, 300223017Sdim const LangOptions &LangOpts, 301223017Sdim const FrontendOptions &FEOpts, 302223017Sdim MacroBuilder &Builder) { 303235633Sdim if (!LangOpts.MicrosoftMode && !LangOpts.TraditionalCPP) 304223017Sdim Builder.defineMacro("__STDC__"); 305223017Sdim if (LangOpts.Freestanding) 306223017Sdim Builder.defineMacro("__STDC_HOSTED__", "0"); 307223017Sdim else 308223017Sdim Builder.defineMacro("__STDC_HOSTED__"); 309223017Sdim 310223017Sdim if (!LangOpts.CPlusPlus) { 311235633Sdim if (LangOpts.C11) 312235633Sdim Builder.defineMacro("__STDC_VERSION__", "201112L"); 313235633Sdim else if (LangOpts.C99) 314223017Sdim Builder.defineMacro("__STDC_VERSION__", "199901L"); 315223017Sdim else if (!LangOpts.GNUMode && LangOpts.Digraphs) 316223017Sdim Builder.defineMacro("__STDC_VERSION__", "199409L"); 317223017Sdim } else { 318252723Sdim // FIXME: Use the right value for __cplusplus for C++1y once one is chosen. 319252723Sdim if (LangOpts.CPlusPlus1y) 320252723Sdim Builder.defineMacro("__cplusplus", "201305L"); 321245431Sdim // C++11 [cpp.predefined]p1: 322245431Sdim // The name __cplusplus is defined to the value 201103L when compiling a 323245431Sdim // C++ translation unit. 324252723Sdim else if (LangOpts.CPlusPlus11) 325245431Sdim Builder.defineMacro("__cplusplus", "201103L"); 326245431Sdim // C++03 [cpp.predefined]p1: 327245431Sdim // The name __cplusplus is defined to the value 199711L when compiling a 328245431Sdim // C++ translation unit. 329245431Sdim else 330245431Sdim Builder.defineMacro("__cplusplus", "199711L"); 331223017Sdim } 332223017Sdim 333263509Sdim // In C11 these are environment macros. In C++11 they are only defined 334263509Sdim // as part of <cuchar>. To prevent breakage when mixing C and C++ 335263509Sdim // code, define these macros unconditionally. We can define them 336263509Sdim // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit 337263509Sdim // and 32-bit character literals. 338263509Sdim Builder.defineMacro("__STDC_UTF_16__", "1"); 339263509Sdim Builder.defineMacro("__STDC_UTF_32__", "1"); 340263509Sdim 341223017Sdim if (LangOpts.ObjC1) 342223017Sdim Builder.defineMacro("__OBJC__"); 343223017Sdim 344223017Sdim // Not "standard" per se, but available even with the -undef flag. 345223017Sdim if (LangOpts.AsmPreprocessor) 346223017Sdim Builder.defineMacro("__ASSEMBLER__"); 347223017Sdim} 348223017Sdim 349263509Sdim/// Initialize the predefined C++ language feature test macros defined in 350263509Sdim/// ISO/IEC JTC1/SC22/WG21 (C++) SD-6: "SG10 Feature Test Recommendations". 351263509Sdimstatic void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts, 352263509Sdim MacroBuilder &Builder) { 353263509Sdim // C++11 features. 354263509Sdim if (LangOpts.CPlusPlus11) { 355263509Sdim Builder.defineMacro("__cpp_unicode_characters", "200704"); 356263509Sdim Builder.defineMacro("__cpp_raw_strings", "200710"); 357263509Sdim Builder.defineMacro("__cpp_unicode_literals", "200710"); 358263509Sdim Builder.defineMacro("__cpp_user_defined_literals", "200809"); 359263509Sdim Builder.defineMacro("__cpp_lambdas", "200907"); 360263509Sdim Builder.defineMacro("__cpp_constexpr", 361263509Sdim LangOpts.CPlusPlus1y ? "201304" : "200704"); 362263509Sdim Builder.defineMacro("__cpp_static_assert", "200410"); 363263509Sdim Builder.defineMacro("__cpp_decltype", "200707"); 364263509Sdim Builder.defineMacro("__cpp_attributes", "200809"); 365263509Sdim Builder.defineMacro("__cpp_rvalue_references", "200610"); 366263509Sdim Builder.defineMacro("__cpp_variadic_templates", "200704"); 367263509Sdim } 368263509Sdim 369263509Sdim // C++14 features. 370263509Sdim if (LangOpts.CPlusPlus1y) { 371263509Sdim Builder.defineMacro("__cpp_binary_literals", "201304"); 372263509Sdim Builder.defineMacro("__cpp_init_captures", "201304"); 373263509Sdim Builder.defineMacro("__cpp_generic_lambdas", "201304"); 374263509Sdim Builder.defineMacro("__cpp_decltype_auto", "201304"); 375263509Sdim Builder.defineMacro("__cpp_return_type_deduction", "201304"); 376263509Sdim Builder.defineMacro("__cpp_aggregate_nsdmi", "201304"); 377263509Sdim Builder.defineMacro("__cpp_variable_templates", "201304"); 378263509Sdim } 379263509Sdim} 380263509Sdim 381193326Sedstatic void InitializePredefinedMacros(const TargetInfo &TI, 382193326Sed const LangOptions &LangOpts, 383202379Srdivacky const FrontendOptions &FEOpts, 384202379Srdivacky MacroBuilder &Builder) { 385193326Sed // Compiler version introspection macros. 386202379Srdivacky Builder.defineMacro("__llvm__"); // LLVM Backend 387202379Srdivacky Builder.defineMacro("__clang__"); // Clang Frontend 388207619Srdivacky#define TOSTR2(X) #X 389207619Srdivacky#define TOSTR(X) TOSTR2(X) 390207619Srdivacky Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR)); 391207619Srdivacky Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR)); 392207619Srdivacky#ifdef CLANG_VERSION_PATCHLEVEL 393207619Srdivacky Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL)); 394207619Srdivacky#else 395207619Srdivacky Builder.defineMacro("__clang_patchlevel__", "0"); 396207619Srdivacky#endif 397207619Srdivacky Builder.defineMacro("__clang_version__", 398245431Sdim "\"" CLANG_VERSION_STRING " " 399245431Sdim + getClangFullRepositoryVersion() + "\""); 400207619Srdivacky#undef TOSTR 401207619Srdivacky#undef TOSTR2 402235633Sdim if (!LangOpts.MicrosoftMode) { 403235633Sdim // Currently claim to be compatible with GCC 4.2.1-5621, but only if we're 404235633Sdim // not compiling for MSVC compatibility 405235633Sdim Builder.defineMacro("__GNUC_MINOR__", "2"); 406235633Sdim Builder.defineMacro("__GNUC_PATCHLEVEL__", "1"); 407235633Sdim Builder.defineMacro("__GNUC__", "4"); 408235633Sdim Builder.defineMacro("__GXX_ABI_VERSION", "1002"); 409235633Sdim } 410198092Srdivacky 411235633Sdim // Define macros for the C11 / C++11 memory orderings 412235633Sdim Builder.defineMacro("__ATOMIC_RELAXED", "0"); 413235633Sdim Builder.defineMacro("__ATOMIC_CONSUME", "1"); 414235633Sdim Builder.defineMacro("__ATOMIC_ACQUIRE", "2"); 415235633Sdim Builder.defineMacro("__ATOMIC_RELEASE", "3"); 416235633Sdim Builder.defineMacro("__ATOMIC_ACQ_REL", "4"); 417235633Sdim Builder.defineMacro("__ATOMIC_SEQ_CST", "5"); 418235633Sdim 419235633Sdim // Support for #pragma redefine_extname (Sun compatibility) 420235633Sdim Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1"); 421235633Sdim 422221345Sdim // As sad as it is, enough software depends on the __VERSION__ for version 423221345Sdim // checks that it is necessary to report 4.2.1 (the base GCC version we claim 424221345Sdim // compatibility with) first. 425221345Sdim Builder.defineMacro("__VERSION__", "\"4.2.1 Compatible " + 426226890Sdim Twine(getClangFullCPPVersion()) + "\""); 427221345Sdim 428193326Sed // Initialize language-specific preprocessor defines. 429198092Srdivacky 430193326Sed // Standard conforming mode? 431193326Sed if (!LangOpts.GNUMode) 432202379Srdivacky Builder.defineMacro("__STRICT_ANSI__"); 433198092Srdivacky 434252723Sdim if (LangOpts.CPlusPlus11) 435202379Srdivacky Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__"); 436193326Sed 437193326Sed if (LangOpts.ObjC1) { 438245431Sdim if (LangOpts.ObjCRuntime.isNonFragile()) { 439202379Srdivacky Builder.defineMacro("__OBJC2__"); 440226890Sdim 441226890Sdim if (LangOpts.ObjCExceptions) 442226890Sdim Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS"); 443193326Sed } 444193326Sed 445226890Sdim if (LangOpts.getGC() != LangOptions::NonGC) 446202379Srdivacky Builder.defineMacro("__OBJC_GC__"); 447198092Srdivacky 448245431Sdim if (LangOpts.ObjCRuntime.isNeXTFamily()) 449202379Srdivacky Builder.defineMacro("__NEXT_RUNTIME__"); 450245431Sdim 451263509Sdim if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::ObjFW) { 452263509Sdim VersionTuple tuple = LangOpts.ObjCRuntime.getVersion(); 453263509Sdim 454263509Sdim unsigned minor = 0; 455263509Sdim if (tuple.getMinor().hasValue()) 456263509Sdim minor = tuple.getMinor().getValue(); 457263509Sdim 458263509Sdim unsigned subminor = 0; 459263509Sdim if (tuple.getSubminor().hasValue()) 460263509Sdim subminor = tuple.getSubminor().getValue(); 461263509Sdim 462263509Sdim Builder.defineMacro("__OBJFW_RUNTIME_ABI__", 463263509Sdim Twine(tuple.getMajor() * 10000 + minor * 100 + 464263509Sdim subminor)); 465263509Sdim } 466263509Sdim 467245431Sdim Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))"); 468245431Sdim Builder.defineMacro("IBOutletCollection(ClassName)", 469245431Sdim "__attribute__((iboutletcollection(ClassName)))"); 470245431Sdim Builder.defineMacro("IBAction", "void)__attribute__((ibaction)"); 471193326Sed } 472198092Srdivacky 473263509Sdim if (LangOpts.CPlusPlus) 474263509Sdim InitializeCPlusPlusFeatureTestMacros(LangOpts, Builder); 475263509Sdim 476193326Sed // darwin_constant_cfstrings controls this. This is also dependent 477193326Sed // on other things like the runtime I believe. This is set even for C code. 478224145Sdim if (!LangOpts.NoConstantCFStrings) 479224145Sdim Builder.defineMacro("__CONSTANT_CFSTRINGS__"); 480198092Srdivacky 481193326Sed if (LangOpts.ObjC2) 482202379Srdivacky Builder.defineMacro("OBJC_NEW_PROPERTIES"); 483193326Sed 484193326Sed if (LangOpts.PascalStrings) 485202379Srdivacky Builder.defineMacro("__PASCAL_STRINGS__"); 486193326Sed 487193326Sed if (LangOpts.Blocks) { 488202379Srdivacky Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))"); 489202379Srdivacky Builder.defineMacro("__BLOCKS__"); 490193326Sed } 491198092Srdivacky 492226890Sdim if (LangOpts.CXXExceptions) 493202379Srdivacky Builder.defineMacro("__EXCEPTIONS"); 494210299Sed if (LangOpts.RTTI) 495210299Sed Builder.defineMacro("__GXX_RTTI"); 496203955Srdivacky if (LangOpts.SjLjExceptions) 497203955Srdivacky Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__"); 498198092Srdivacky 499221345Sdim if (LangOpts.Deprecated) 500221345Sdim Builder.defineMacro("__DEPRECATED"); 501221345Sdim 502193326Sed if (LangOpts.CPlusPlus) { 503202379Srdivacky Builder.defineMacro("__GNUG__", "4"); 504202379Srdivacky Builder.defineMacro("__GXX_WEAK__"); 505202379Srdivacky Builder.defineMacro("__private_extern__", "extern"); 506193326Sed } 507198092Srdivacky 508226890Sdim if (LangOpts.MicrosoftExt) { 509200583Srdivacky // Both __PRETTY_FUNCTION__ and __FUNCTION__ are GCC extensions, however 510200583Srdivacky // VC++ appears to only like __FUNCTION__. 511202379Srdivacky Builder.defineMacro("__PRETTY_FUNCTION__", "__FUNCTION__"); 512245431Sdim // Work around some issues with Visual C++ headers. 513245431Sdim if (LangOpts.WChar) { 514245431Sdim // wchar_t supported as a keyword. 515202379Srdivacky Builder.defineMacro("_WCHAR_T_DEFINED"); 516202379Srdivacky Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED"); 517245431Sdim } 518245431Sdim if (LangOpts.CPlusPlus) { 519223017Sdim // FIXME: Support Microsoft's __identifier extension in the lexer. 520223017Sdim Builder.append("#define __identifier(x) x"); 521212904Sdim Builder.append("class type_info;"); 522198398Srdivacky } 523193326Sed } 524198092Srdivacky 525193326Sed if (LangOpts.Optimize) 526202379Srdivacky Builder.defineMacro("__OPTIMIZE__"); 527193326Sed if (LangOpts.OptimizeSize) 528202379Srdivacky Builder.defineMacro("__OPTIMIZE_SIZE__"); 529198092Srdivacky 530235633Sdim if (LangOpts.FastMath) 531235633Sdim Builder.defineMacro("__FAST_MATH__"); 532235633Sdim 533193326Sed // Initialize target-specific preprocessor defines. 534198092Srdivacky 535245431Sdim // __BYTE_ORDER__ was added in GCC 4.6. It's analogous 536245431Sdim // to the macro __BYTE_ORDER (no trailing underscores) 537245431Sdim // from glibc's <endian.h> header. 538245431Sdim // We don't support the PDP-11 as a target, but include 539245431Sdim // the define so it can still be compared against. 540245431Sdim Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234"); 541245431Sdim Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321"); 542245431Sdim Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412"); 543245431Sdim if (TI.isBigEndian()) 544245431Sdim Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__"); 545245431Sdim else 546245431Sdim Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__"); 547245431Sdim 548245431Sdim 549245431Sdim if (TI.getPointerWidth(0) == 64 && TI.getLongWidth() == 64 550245431Sdim && TI.getIntWidth() == 32) { 551245431Sdim Builder.defineMacro("_LP64"); 552245431Sdim Builder.defineMacro("__LP64__"); 553245431Sdim } 554245431Sdim 555193326Sed // Define type sizing macros based on the target properties. 556193326Sed assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far"); 557202379Srdivacky Builder.defineMacro("__CHAR_BIT__", "8"); 558193326Sed 559263509Sdim DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder); 560202379Srdivacky DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder); 561202379Srdivacky DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder); 562202379Srdivacky DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder); 563202379Srdivacky DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder); 564202379Srdivacky DefineTypeSize("__WCHAR_MAX__", TI.getWCharType(), TI, Builder); 565202379Srdivacky DefineTypeSize("__INTMAX_MAX__", TI.getIntMaxType(), TI, Builder); 566252723Sdim DefineTypeSize("__SIZE_MAX__", TI.getSizeType(), TI, Builder); 567193326Sed 568210299Sed DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder); 569210299Sed DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder); 570210299Sed DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder); 571210299Sed DefineTypeSizeof("__SIZEOF_LONG__", TI.getLongWidth(), TI, Builder); 572210299Sed DefineTypeSizeof("__SIZEOF_LONG_DOUBLE__",TI.getLongDoubleWidth(),TI,Builder); 573210299Sed DefineTypeSizeof("__SIZEOF_LONG_LONG__", TI.getLongLongWidth(), TI, Builder); 574210299Sed DefineTypeSizeof("__SIZEOF_POINTER__", TI.getPointerWidth(0), TI, Builder); 575210299Sed DefineTypeSizeof("__SIZEOF_SHORT__", TI.getShortWidth(), TI, Builder); 576210299Sed DefineTypeSizeof("__SIZEOF_PTRDIFF_T__", 577210299Sed TI.getTypeWidth(TI.getPtrDiffType(0)), TI, Builder); 578210299Sed DefineTypeSizeof("__SIZEOF_SIZE_T__", 579210299Sed TI.getTypeWidth(TI.getSizeType()), TI, Builder); 580210299Sed DefineTypeSizeof("__SIZEOF_WCHAR_T__", 581210299Sed TI.getTypeWidth(TI.getWCharType()), TI, Builder); 582210299Sed DefineTypeSizeof("__SIZEOF_WINT_T__", 583210299Sed TI.getTypeWidth(TI.getWIntType()), TI, Builder); 584252723Sdim if (TI.hasInt128Type()) 585252723Sdim DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder); 586210299Sed 587202379Srdivacky DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder); 588202379Srdivacky DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder); 589202379Srdivacky DefineTypeWidth("__INTMAX_WIDTH__", TI.getIntMaxType(), TI, Builder); 590202379Srdivacky DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Builder); 591202379Srdivacky DefineTypeWidth("__PTRDIFF_WIDTH__", TI.getPtrDiffType(0), TI, Builder); 592202379Srdivacky DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder); 593202379Srdivacky DefineTypeWidth("__INTPTR_WIDTH__", TI.getIntPtrType(), TI, Builder); 594202379Srdivacky DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder); 595202379Srdivacky DefineTypeWidth("__SIZE_WIDTH__", TI.getSizeType(), TI, Builder); 596202379Srdivacky DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder); 597202379Srdivacky DefineTypeWidth("__WCHAR_WIDTH__", TI.getWCharType(), TI, Builder); 598202379Srdivacky DefineType("__WINT_TYPE__", TI.getWIntType(), Builder); 599202379Srdivacky DefineTypeWidth("__WINT_WIDTH__", TI.getWIntType(), TI, Builder); 600202379Srdivacky DefineTypeWidth("__SIG_ATOMIC_WIDTH__", TI.getSigAtomicType(), TI, Builder); 601210299Sed DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder); 602210299Sed DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder); 603198092Srdivacky 604245431Sdim DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F"); 605245431Sdim DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), ""); 606245431Sdim DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L"); 607193326Sed 608193326Sed // Define a __POINTER_WIDTH__ macro for stdint.h. 609202379Srdivacky Builder.defineMacro("__POINTER_WIDTH__", 610226890Sdim Twine((int)TI.getPointerWidth(0))); 611198092Srdivacky 612193576Sed if (!LangOpts.CharIsSigned) 613202379Srdivacky Builder.defineMacro("__CHAR_UNSIGNED__"); 614193326Sed 615245431Sdim if (!TargetInfo::isTypeSigned(TI.getWCharType())) 616245431Sdim Builder.defineMacro("__WCHAR_UNSIGNED__"); 617245431Sdim 618221345Sdim if (!TargetInfo::isTypeSigned(TI.getWIntType())) 619221345Sdim Builder.defineMacro("__WINT_UNSIGNED__"); 620221345Sdim 621199482Srdivacky // Define exact-width integer types for stdint.h 622226890Sdim Builder.defineMacro("__INT" + Twine(TI.getCharWidth()) + "_TYPE__", 623202379Srdivacky "char"); 624198092Srdivacky 625199482Srdivacky if (TI.getShortWidth() > TI.getCharWidth()) 626202379Srdivacky DefineExactWidthIntType(TargetInfo::SignedShort, TI, Builder); 627202379Srdivacky 628199482Srdivacky if (TI.getIntWidth() > TI.getShortWidth()) 629202379Srdivacky DefineExactWidthIntType(TargetInfo::SignedInt, TI, Builder); 630202379Srdivacky 631199482Srdivacky if (TI.getLongWidth() > TI.getIntWidth()) 632202379Srdivacky DefineExactWidthIntType(TargetInfo::SignedLong, TI, Builder); 633202379Srdivacky 634199482Srdivacky if (TI.getLongLongWidth() > TI.getLongWidth()) 635202379Srdivacky DefineExactWidthIntType(TargetInfo::SignedLongLong, TI, Builder); 636202379Srdivacky 637202379Srdivacky if (const char *Prefix = TI.getUserLabelPrefix()) 638202379Srdivacky Builder.defineMacro("__USER_LABEL_PREFIX__", Prefix); 639198092Srdivacky 640245431Sdim if (LangOpts.FastMath || LangOpts.FiniteMathOnly) 641245431Sdim Builder.defineMacro("__FINITE_MATH_ONLY__", "1"); 642245431Sdim else 643245431Sdim Builder.defineMacro("__FINITE_MATH_ONLY__", "0"); 644193326Sed 645193326Sed if (LangOpts.GNUInline) 646202379Srdivacky Builder.defineMacro("__GNUC_GNU_INLINE__"); 647193326Sed else 648202379Srdivacky Builder.defineMacro("__GNUC_STDC_INLINE__"); 649193326Sed 650235633Sdim // The value written by __atomic_test_and_set. 651235633Sdim // FIXME: This is target-dependent. 652235633Sdim Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1"); 653235633Sdim 654235633Sdim // Used by libstdc++ to implement ATOMIC_<foo>_LOCK_FREE. 655235633Sdim unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth(); 656235633Sdim#define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \ 657235633Sdim Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \ 658235633Sdim getLockFreeValue(TI.get##Type##Width(), \ 659235633Sdim TI.get##Type##Align(), \ 660235633Sdim InlineWidthBits)); 661235633Sdim DEFINE_LOCK_FREE_MACRO(BOOL, Bool); 662235633Sdim DEFINE_LOCK_FREE_MACRO(CHAR, Char); 663235633Sdim DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16); 664235633Sdim DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32); 665235633Sdim DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar); 666235633Sdim DEFINE_LOCK_FREE_MACRO(SHORT, Short); 667235633Sdim DEFINE_LOCK_FREE_MACRO(INT, Int); 668235633Sdim DEFINE_LOCK_FREE_MACRO(LONG, Long); 669235633Sdim DEFINE_LOCK_FREE_MACRO(LLONG, LongLong); 670235633Sdim Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE", 671235633Sdim getLockFreeValue(TI.getPointerWidth(0), 672235633Sdim TI.getPointerAlign(0), 673235633Sdim InlineWidthBits)); 674235633Sdim#undef DEFINE_LOCK_FREE_MACRO 675235633Sdim 676235633Sdim if (LangOpts.NoInlineDefine) 677202379Srdivacky Builder.defineMacro("__NO_INLINE__"); 678193326Sed 679193326Sed if (unsigned PICLevel = LangOpts.PICLevel) { 680226890Sdim Builder.defineMacro("__PIC__", Twine(PICLevel)); 681226890Sdim Builder.defineMacro("__pic__", Twine(PICLevel)); 682193326Sed } 683235633Sdim if (unsigned PIELevel = LangOpts.PIELevel) { 684235633Sdim Builder.defineMacro("__PIE__", Twine(PIELevel)); 685235633Sdim Builder.defineMacro("__pie__", Twine(PIELevel)); 686235633Sdim } 687193326Sed 688193326Sed // Macros to control C99 numerics and <float.h> 689235633Sdim Builder.defineMacro("__FLT_EVAL_METHOD__", Twine(TI.getFloatEvalMethod())); 690202379Srdivacky Builder.defineMacro("__FLT_RADIX__", "2"); 691202379Srdivacky int Dig = PickFP(&TI.getLongDoubleFormat(), -1/*FIXME*/, 17, 21, 33, 36); 692226890Sdim Builder.defineMacro("__DECIMAL_DIG__", Twine(Dig)); 693195341Sed 694226890Sdim if (LangOpts.getStackProtector() == LangOptions::SSPOn) 695202379Srdivacky Builder.defineMacro("__SSP__"); 696226890Sdim else if (LangOpts.getStackProtector() == LangOptions::SSPReq) 697202379Srdivacky Builder.defineMacro("__SSP_ALL__", "2"); 698195341Sed 699202379Srdivacky if (FEOpts.ProgramAction == frontend::RewriteObjC) 700202379Srdivacky Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))"); 701208600Srdivacky 702208600Srdivacky // Define a macro that exists only when using the static analyzer. 703208600Srdivacky if (FEOpts.ProgramAction == frontend::RunAnalysis) 704208600Srdivacky Builder.defineMacro("__clang_analyzer__"); 705208600Srdivacky 706218893Sdim if (LangOpts.FastRelaxedMath) 707218893Sdim Builder.defineMacro("__FAST_RELAXED_MATH__"); 708218893Sdim 709224145Sdim if (LangOpts.ObjCAutoRefCount) { 710224145Sdim Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))"); 711224145Sdim Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))"); 712224145Sdim Builder.defineMacro("__autoreleasing", 713224145Sdim "__attribute__((objc_ownership(autoreleasing)))"); 714224145Sdim Builder.defineMacro("__unsafe_unretained", 715224145Sdim "__attribute__((objc_ownership(none)))"); 716224145Sdim } 717224145Sdim 718252723Sdim // OpenMP definition 719252723Sdim if (LangOpts.OpenMP) { 720252723Sdim // OpenMP 2.2: 721252723Sdim // In implementations that support a preprocessor, the _OPENMP 722252723Sdim // macro name is defined to have the decimal value yyyymm where 723252723Sdim // yyyy and mm are the year and the month designations of the 724252723Sdim // version of the OpenMP API that the implementation support. 725252723Sdim Builder.defineMacro("_OPENMP", "201107"); 726252723Sdim } 727252723Sdim 728193326Sed // Get other target #defines. 729202379Srdivacky TI.getTargetDefines(LangOpts, Builder); 730193326Sed} 731193326Sed 732200583Srdivacky// Initialize the remapping of files to alternative contents, e.g., 733200583Srdivacky// those specified through other files. 734226890Sdimstatic void InitializeFileRemapping(DiagnosticsEngine &Diags, 735200583Srdivacky SourceManager &SourceMgr, 736200583Srdivacky FileManager &FileMgr, 737200583Srdivacky const PreprocessorOptions &InitOpts) { 738202879Srdivacky // Remap files in the source manager (with buffers). 739212904Sdim for (PreprocessorOptions::const_remapped_file_buffer_iterator 740202879Srdivacky Remap = InitOpts.remapped_file_buffer_begin(), 741202879Srdivacky RemapEnd = InitOpts.remapped_file_buffer_end(); 742202879Srdivacky Remap != RemapEnd; 743202879Srdivacky ++Remap) { 744202879Srdivacky // Create the file entry for the file that we're mapping from. 745202879Srdivacky const FileEntry *FromFile = FileMgr.getVirtualFile(Remap->first, 746202879Srdivacky Remap->second->getBufferSize(), 747202879Srdivacky 0); 748202879Srdivacky if (!FromFile) { 749202879Srdivacky Diags.Report(diag::err_fe_remap_missing_from_file) 750202879Srdivacky << Remap->first; 751212904Sdim if (!InitOpts.RetainRemappedFileBuffers) 752212904Sdim delete Remap->second; 753202879Srdivacky continue; 754202879Srdivacky } 755202879Srdivacky 756202879Srdivacky // Override the contents of the "from" file with the contents of 757202879Srdivacky // the "to" file. 758212904Sdim SourceMgr.overrideFileContents(FromFile, Remap->second, 759212904Sdim InitOpts.RetainRemappedFileBuffers); 760202879Srdivacky } 761202879Srdivacky 762202879Srdivacky // Remap files in the source manager (with other files). 763212904Sdim for (PreprocessorOptions::const_remapped_file_iterator 764212904Sdim Remap = InitOpts.remapped_file_begin(), 765212904Sdim RemapEnd = InitOpts.remapped_file_end(); 766200583Srdivacky Remap != RemapEnd; 767200583Srdivacky ++Remap) { 768200583Srdivacky // Find the file that we're mapping to. 769200583Srdivacky const FileEntry *ToFile = FileMgr.getFile(Remap->second); 770200583Srdivacky if (!ToFile) { 771200583Srdivacky Diags.Report(diag::err_fe_remap_missing_to_file) 772202879Srdivacky << Remap->first << Remap->second; 773200583Srdivacky continue; 774200583Srdivacky } 775202879Srdivacky 776200583Srdivacky // Create the file entry for the file that we're mapping from. 777200583Srdivacky const FileEntry *FromFile = FileMgr.getVirtualFile(Remap->first, 778218893Sdim ToFile->getSize(), 0); 779200583Srdivacky if (!FromFile) { 780200583Srdivacky Diags.Report(diag::err_fe_remap_missing_from_file) 781202879Srdivacky << Remap->first; 782200583Srdivacky continue; 783200583Srdivacky } 784202879Srdivacky 785200583Srdivacky // Override the contents of the "from" file with the contents of 786200583Srdivacky // the "to" file. 787221345Sdim SourceMgr.overrideFileContents(FromFile, ToFile); 788200583Srdivacky } 789221345Sdim 790221345Sdim SourceMgr.setOverridenFilesKeepOriginalName( 791221345Sdim InitOpts.RemappedFilesKeepOriginalName); 792200583Srdivacky} 793200583Srdivacky 794193326Sed/// InitializePreprocessor - Initialize the preprocessor getting it and the 795193326Sed/// environment ready to process a single file. This returns true on error. 796193326Sed/// 797198954Srdivackyvoid clang::InitializePreprocessor(Preprocessor &PP, 798199482Srdivacky const PreprocessorOptions &InitOpts, 799202379Srdivacky const HeaderSearchOptions &HSOpts, 800202379Srdivacky const FrontendOptions &FEOpts) { 801235633Sdim const LangOptions &LangOpts = PP.getLangOpts(); 802202379Srdivacky std::string PredefineBuffer; 803202379Srdivacky PredefineBuffer.reserve(4080); 804202379Srdivacky llvm::raw_string_ostream Predefines(PredefineBuffer); 805202379Srdivacky MacroBuilder Builder(Predefines); 806198092Srdivacky 807200583Srdivacky InitializeFileRemapping(PP.getDiagnostics(), PP.getSourceManager(), 808200583Srdivacky PP.getFileManager(), InitOpts); 809200583Srdivacky 810207619Srdivacky // Emit line markers for various builtin sections of the file. We don't do 811207619Srdivacky // this in asm preprocessor mode, because "# 4" is not a line marker directive 812207619Srdivacky // in this mode. 813235633Sdim if (!PP.getLangOpts().AsmPreprocessor) 814207619Srdivacky Builder.append("# 1 \"<built-in>\" 3"); 815198092Srdivacky 816193326Sed // Install things like __POWERPC__, __GNUC__, etc into the macro table. 817224145Sdim if (InitOpts.UsePredefines) { 818224145Sdim InitializePredefinedMacros(PP.getTargetInfo(), LangOpts, FEOpts, Builder); 819198092Srdivacky 820224145Sdim // Install definitions to make Objective-C++ ARC work well with various 821224145Sdim // C++ Standard Library implementations. 822224145Sdim if (LangOpts.ObjC1 && LangOpts.CPlusPlus && LangOpts.ObjCAutoRefCount) { 823224145Sdim switch (InitOpts.ObjCXXARCStandardLibrary) { 824224145Sdim case ARCXX_nolib: 825226890Sdim case ARCXX_libcxx: 826224145Sdim break; 827224145Sdim 828224145Sdim case ARCXX_libstdcxx: 829224145Sdim AddObjCXXARCLibstdcxxDefines(LangOpts, Builder); 830224145Sdim break; 831224145Sdim } 832224145Sdim } 833224145Sdim } 834224145Sdim 835223017Sdim // Even with predefines off, some macros are still predefined. 836223017Sdim // These should all be defined in the preprocessor according to the 837223017Sdim // current language configuration. 838235633Sdim InitializeStandardPredefinedMacros(PP.getTargetInfo(), PP.getLangOpts(), 839223017Sdim FEOpts, Builder); 840223017Sdim 841193326Sed // Add on the predefines from the driver. Wrap in a #line directive to report 842193326Sed // that they come from the command line. 843235633Sdim if (!PP.getLangOpts().AsmPreprocessor) 844207619Srdivacky Builder.append("# 1 \"<command line>\" 1"); 845193326Sed 846193326Sed // Process #define's and #undef's in the order they are given. 847199482Srdivacky for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) { 848199482Srdivacky if (InitOpts.Macros[i].second) // isUndef 849202379Srdivacky Builder.undefineMacro(InitOpts.Macros[i].first); 850193326Sed else 851202379Srdivacky DefineBuiltinMacro(Builder, InitOpts.Macros[i].first, 852202379Srdivacky PP.getDiagnostics()); 853193326Sed } 854193326Sed 855193326Sed // If -imacros are specified, include them now. These are processed before 856193326Sed // any -include directives. 857199482Srdivacky for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i) 858219077Sdim AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i], 859219077Sdim PP.getFileManager()); 860193326Sed 861252723Sdim // Process -include-pch/-include-pth directives. 862252723Sdim if (!InitOpts.ImplicitPCHInclude.empty()) 863252723Sdim AddImplicitIncludePCH(Builder, PP, InitOpts.ImplicitPCHInclude); 864252723Sdim if (!InitOpts.ImplicitPTHInclude.empty()) 865252723Sdim AddImplicitIncludePTH(Builder, PP, InitOpts.ImplicitPTHInclude); 866252723Sdim 867193326Sed // Process -include directives. 868199482Srdivacky for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) { 869199482Srdivacky const std::string &Path = InitOpts.Includes[i]; 870252723Sdim AddImplicitInclude(Builder, Path, PP.getFileManager()); 871194613Sed } 872193326Sed 873200583Srdivacky // Exit the command line and go back to <built-in> (2 is LC_LEAVE). 874235633Sdim if (!PP.getLangOpts().AsmPreprocessor) 875207619Srdivacky Builder.append("# 1 \"<built-in>\" 2"); 876200583Srdivacky 877212904Sdim // Instruct the preprocessor to skip the preamble. 878212904Sdim PP.setSkipMainFilePreamble(InitOpts.PrecompiledPreambleBytes.first, 879212904Sdim InitOpts.PrecompiledPreambleBytes.second); 880212904Sdim 881202379Srdivacky // Copy PredefinedBuffer into the Preprocessor. 882202379Srdivacky PP.setPredefines(Predefines.str()); 883226890Sdim 884199482Srdivacky // Initialize the header search object. 885199482Srdivacky ApplyHeaderSearchOptions(PP.getHeaderSearchInfo(), HSOpts, 886235633Sdim PP.getLangOpts(), 887199482Srdivacky PP.getTargetInfo().getTriple()); 888193326Sed} 889