1 //===--- InitPreprocessor.cpp - PP initialization code. ---------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the clang::InitializePreprocessor function.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Frontend/Utils.h"
15 #include "clang/Basic/FileManager.h"
16 #include "clang/Basic/MacroBuilder.h"
17 #include "clang/Basic/SourceManager.h"
18 #include "clang/Basic/TargetInfo.h"
19 #include "clang/Basic/Version.h"
20 #include "clang/Frontend/FrontendDiagnostic.h"
21 #include "clang/Frontend/FrontendOptions.h"
22 #include "clang/Lex/HeaderSearch.h"
23 #include "clang/Lex/Preprocessor.h"
24 #include "clang/Lex/PreprocessorOptions.h"
25 #include "clang/Serialization/ASTReader.h"
26 #include "llvm/ADT/APFloat.h"
27 #include "llvm/Support/FileSystem.h"
28 #include "llvm/Support/MemoryBuffer.h"
29 #include "llvm/Support/Path.h"
30 using namespace clang;
31 
MacroBodyEndsInBackslash(StringRef MacroBody)32 static bool MacroBodyEndsInBackslash(StringRef MacroBody) {
33   while (!MacroBody.empty() && isWhitespace(MacroBody.back()))
34     MacroBody = MacroBody.drop_back();
35   return !MacroBody.empty() && MacroBody.back() == '\\';
36 }
37 
38 // Append a #define line to Buf for Macro.  Macro should be of the form XXX,
39 // in which case we emit "#define XXX 1" or "XXX=Y z W" in which case we emit
40 // "#define XXX Y z W".  To get a #define with no value, use "XXX=".
DefineBuiltinMacro(MacroBuilder & Builder,StringRef Macro,DiagnosticsEngine & Diags)41 static void DefineBuiltinMacro(MacroBuilder &Builder, StringRef Macro,
42                                DiagnosticsEngine &Diags) {
43   std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
44   StringRef MacroName = MacroPair.first;
45   StringRef MacroBody = MacroPair.second;
46   if (MacroName.size() != Macro.size()) {
47     // Per GCC -D semantics, the macro ends at \n if it exists.
48     StringRef::size_type End = MacroBody.find_first_of("\n\r");
49     if (End != StringRef::npos)
50       Diags.Report(diag::warn_fe_macro_contains_embedded_newline)
51         << MacroName;
52     MacroBody = MacroBody.substr(0, End);
53     // We handle macro bodies which end in a backslash by appending an extra
54     // backslash+newline.  This makes sure we don't accidentally treat the
55     // backslash as a line continuation marker.
56     if (MacroBodyEndsInBackslash(MacroBody))
57       Builder.defineMacro(MacroName, Twine(MacroBody) + "\\\n");
58     else
59       Builder.defineMacro(MacroName, MacroBody);
60   } else {
61     // Push "macroname 1".
62     Builder.defineMacro(Macro);
63   }
64 }
65 
66 /// AddImplicitInclude - Add an implicit \#include of the specified file to the
67 /// predefines buffer.
68 /// As these includes are generated by -include arguments the header search
69 /// logic is going to search relatively to the current working directory.
AddImplicitInclude(MacroBuilder & Builder,StringRef File)70 static void AddImplicitInclude(MacroBuilder &Builder, StringRef File) {
71   Builder.append(Twine("#include \"") + File + "\"");
72 }
73 
AddImplicitIncludeMacros(MacroBuilder & Builder,StringRef File)74 static void AddImplicitIncludeMacros(MacroBuilder &Builder, StringRef File) {
75   Builder.append(Twine("#__include_macros \"") + File + "\"");
76   // Marker token to stop the __include_macros fetch loop.
77   Builder.append("##"); // ##?
78 }
79 
80 /// AddImplicitIncludePTH - Add an implicit \#include using the original file
81 /// used to generate a PTH cache.
AddImplicitIncludePTH(MacroBuilder & Builder,Preprocessor & PP,StringRef ImplicitIncludePTH)82 static void AddImplicitIncludePTH(MacroBuilder &Builder, Preprocessor &PP,
83                                   StringRef ImplicitIncludePTH) {
84   PTHManager *P = PP.getPTHManager();
85   // Null check 'P' in the corner case where it couldn't be created.
86   const char *OriginalFile = P ? P->getOriginalSourceFile() : nullptr;
87 
88   if (!OriginalFile) {
89     PP.getDiagnostics().Report(diag::err_fe_pth_file_has_no_source_header)
90       << ImplicitIncludePTH;
91     return;
92   }
93 
94   AddImplicitInclude(Builder, OriginalFile);
95 }
96 
97 /// \brief Add an implicit \#include using the original file used to generate
98 /// a PCH file.
AddImplicitIncludePCH(MacroBuilder & Builder,Preprocessor & PP,StringRef ImplicitIncludePCH)99 static void AddImplicitIncludePCH(MacroBuilder &Builder, Preprocessor &PP,
100                                   StringRef ImplicitIncludePCH) {
101   std::string OriginalFile =
102     ASTReader::getOriginalSourceFile(ImplicitIncludePCH, PP.getFileManager(),
103                                      PP.getDiagnostics());
104   if (OriginalFile.empty())
105     return;
106 
107   AddImplicitInclude(Builder, OriginalFile);
108 }
109 
110 /// PickFP - This is used to pick a value based on the FP semantics of the
111 /// specified FP model.
112 template <typename T>
PickFP(const llvm::fltSemantics * Sem,T IEEESingleVal,T IEEEDoubleVal,T X87DoubleExtendedVal,T PPCDoubleDoubleVal,T IEEEQuadVal)113 static T PickFP(const llvm::fltSemantics *Sem, T IEEESingleVal,
114                 T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal,
115                 T IEEEQuadVal) {
116   if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEsingle)
117     return IEEESingleVal;
118   if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEdouble)
119     return IEEEDoubleVal;
120   if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::x87DoubleExtended)
121     return X87DoubleExtendedVal;
122   if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::PPCDoubleDouble)
123     return PPCDoubleDoubleVal;
124   assert(Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEquad);
125   return IEEEQuadVal;
126 }
127 
DefineFloatMacros(MacroBuilder & Builder,StringRef Prefix,const llvm::fltSemantics * Sem,StringRef Ext)128 static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix,
129                               const llvm::fltSemantics *Sem, StringRef Ext) {
130   const char *DenormMin, *Epsilon, *Max, *Min;
131   DenormMin = PickFP(Sem, "1.40129846e-45", "4.9406564584124654e-324",
132                      "3.64519953188247460253e-4951",
133                      "4.94065645841246544176568792868221e-324",
134                      "6.47517511943802511092443895822764655e-4966");
135   int Digits = PickFP(Sem, 6, 15, 18, 31, 33);
136   Epsilon = PickFP(Sem, "1.19209290e-7", "2.2204460492503131e-16",
137                    "1.08420217248550443401e-19",
138                    "4.94065645841246544176568792868221e-324",
139                    "1.92592994438723585305597794258492732e-34");
140   int MantissaDigits = PickFP(Sem, 24, 53, 64, 106, 113);
141   int Min10Exp = PickFP(Sem, -37, -307, -4931, -291, -4931);
142   int Max10Exp = PickFP(Sem, 38, 308, 4932, 308, 4932);
143   int MinExp = PickFP(Sem, -125, -1021, -16381, -968, -16381);
144   int MaxExp = PickFP(Sem, 128, 1024, 16384, 1024, 16384);
145   Min = PickFP(Sem, "1.17549435e-38", "2.2250738585072014e-308",
146                "3.36210314311209350626e-4932",
147                "2.00416836000897277799610805135016e-292",
148                "3.36210314311209350626267781732175260e-4932");
149   Max = PickFP(Sem, "3.40282347e+38", "1.7976931348623157e+308",
150                "1.18973149535723176502e+4932",
151                "1.79769313486231580793728971405301e+308",
152                "1.18973149535723176508575932662800702e+4932");
153 
154   SmallString<32> DefPrefix;
155   DefPrefix = "__";
156   DefPrefix += Prefix;
157   DefPrefix += "_";
158 
159   Builder.defineMacro(DefPrefix + "DENORM_MIN__", Twine(DenormMin)+Ext);
160   Builder.defineMacro(DefPrefix + "HAS_DENORM__");
161   Builder.defineMacro(DefPrefix + "DIG__", Twine(Digits));
162   Builder.defineMacro(DefPrefix + "EPSILON__", Twine(Epsilon)+Ext);
163   Builder.defineMacro(DefPrefix + "HAS_INFINITY__");
164   Builder.defineMacro(DefPrefix + "HAS_QUIET_NAN__");
165   Builder.defineMacro(DefPrefix + "MANT_DIG__", Twine(MantissaDigits));
166 
167   Builder.defineMacro(DefPrefix + "MAX_10_EXP__", Twine(Max10Exp));
168   Builder.defineMacro(DefPrefix + "MAX_EXP__", Twine(MaxExp));
169   Builder.defineMacro(DefPrefix + "MAX__", Twine(Max)+Ext);
170 
171   Builder.defineMacro(DefPrefix + "MIN_10_EXP__","("+Twine(Min10Exp)+")");
172   Builder.defineMacro(DefPrefix + "MIN_EXP__", "("+Twine(MinExp)+")");
173   Builder.defineMacro(DefPrefix + "MIN__", Twine(Min)+Ext);
174 }
175 
176 
177 /// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro
178 /// named MacroName with the max value for a type with width 'TypeWidth' a
179 /// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL).
DefineTypeSize(const Twine & MacroName,unsigned TypeWidth,StringRef ValSuffix,bool isSigned,MacroBuilder & Builder)180 static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth,
181                            StringRef ValSuffix, bool isSigned,
182                            MacroBuilder &Builder) {
183   llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth)
184                                 : llvm::APInt::getMaxValue(TypeWidth);
185   Builder.defineMacro(MacroName, MaxVal.toString(10, isSigned) + ValSuffix);
186 }
187 
188 /// DefineTypeSize - An overloaded helper that uses TargetInfo to determine
189 /// the width, suffix, and signedness of the given type
DefineTypeSize(const Twine & MacroName,TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)190 static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty,
191                            const TargetInfo &TI, MacroBuilder &Builder) {
192   DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty),
193                  TI.isTypeSigned(Ty), Builder);
194 }
195 
DefineFmt(const Twine & Prefix,TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)196 static void DefineFmt(const Twine &Prefix, TargetInfo::IntType Ty,
197                       const TargetInfo &TI, MacroBuilder &Builder) {
198   bool IsSigned = TI.isTypeSigned(Ty);
199   StringRef FmtModifier = TI.getTypeFormatModifier(Ty);
200   for (const char *Fmt = IsSigned ? "di" : "ouxX"; *Fmt; ++Fmt) {
201     Builder.defineMacro(Prefix + "_FMT" + Twine(*Fmt) + "__",
202                         Twine("\"") + FmtModifier + Twine(*Fmt) + "\"");
203   }
204 }
205 
DefineType(const Twine & MacroName,TargetInfo::IntType Ty,MacroBuilder & Builder)206 static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty,
207                        MacroBuilder &Builder) {
208   Builder.defineMacro(MacroName, TargetInfo::getTypeName(Ty));
209 }
210 
DefineTypeWidth(StringRef MacroName,TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)211 static void DefineTypeWidth(StringRef MacroName, TargetInfo::IntType Ty,
212                             const TargetInfo &TI, MacroBuilder &Builder) {
213   Builder.defineMacro(MacroName, Twine(TI.getTypeWidth(Ty)));
214 }
215 
DefineTypeSizeof(StringRef MacroName,unsigned BitWidth,const TargetInfo & TI,MacroBuilder & Builder)216 static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth,
217                              const TargetInfo &TI, MacroBuilder &Builder) {
218   Builder.defineMacro(MacroName,
219                       Twine(BitWidth / TI.getCharWidth()));
220 }
221 
DefineExactWidthIntType(TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)222 static void DefineExactWidthIntType(TargetInfo::IntType Ty,
223                                     const TargetInfo &TI,
224                                     MacroBuilder &Builder) {
225   int TypeWidth = TI.getTypeWidth(Ty);
226   bool IsSigned = TI.isTypeSigned(Ty);
227 
228   // Use the target specified int64 type, when appropriate, so that [u]int64_t
229   // ends up being defined in terms of the correct type.
230   if (TypeWidth == 64)
231     Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
232 
233   const char *Prefix = IsSigned ? "__INT" : "__UINT";
234 
235   DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
236   DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
237 
238   StringRef ConstSuffix(TI.getTypeConstantSuffix(Ty));
239   Builder.defineMacro(Prefix + Twine(TypeWidth) + "_C_SUFFIX__", ConstSuffix);
240 }
241 
DefineExactWidthIntTypeSize(TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)242 static void DefineExactWidthIntTypeSize(TargetInfo::IntType Ty,
243                                         const TargetInfo &TI,
244                                         MacroBuilder &Builder) {
245   int TypeWidth = TI.getTypeWidth(Ty);
246   bool IsSigned = TI.isTypeSigned(Ty);
247 
248   // Use the target specified int64 type, when appropriate, so that [u]int64_t
249   // ends up being defined in terms of the correct type.
250   if (TypeWidth == 64)
251     Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
252 
253   const char *Prefix = IsSigned ? "__INT" : "__UINT";
254   DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
255 }
256 
DefineLeastWidthIntType(unsigned TypeWidth,bool IsSigned,const TargetInfo & TI,MacroBuilder & Builder)257 static void DefineLeastWidthIntType(unsigned TypeWidth, bool IsSigned,
258                                     const TargetInfo &TI,
259                                     MacroBuilder &Builder) {
260   TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
261   if (Ty == TargetInfo::NoInt)
262     return;
263 
264   const char *Prefix = IsSigned ? "__INT_LEAST" : "__UINT_LEAST";
265   DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
266   DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
267   DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
268 }
269 
DefineFastIntType(unsigned TypeWidth,bool IsSigned,const TargetInfo & TI,MacroBuilder & Builder)270 static void DefineFastIntType(unsigned TypeWidth, bool IsSigned,
271                               const TargetInfo &TI, MacroBuilder &Builder) {
272   // stdint.h currently defines the fast int types as equivalent to the least
273   // types.
274   TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
275   if (Ty == TargetInfo::NoInt)
276     return;
277 
278   const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST";
279   DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
280   DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
281 
282   DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
283 }
284 
285 
286 /// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with
287 /// the specified properties.
getLockFreeValue(unsigned TypeWidth,unsigned TypeAlign,unsigned InlineWidth)288 static const char *getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign,
289                                     unsigned InlineWidth) {
290   // Fully-aligned, power-of-2 sizes no larger than the inline
291   // width will be inlined as lock-free operations.
292   if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 &&
293       TypeWidth <= InlineWidth)
294     return "2"; // "always lock free"
295   // We cannot be certain what operations the lib calls might be
296   // able to implement as lock-free on future processors.
297   return "1"; // "sometimes lock free"
298 }
299 
300 /// \brief Add definitions required for a smooth interaction between
301 /// Objective-C++ automated reference counting and libstdc++ (4.2).
AddObjCXXARCLibstdcxxDefines(const LangOptions & LangOpts,MacroBuilder & Builder)302 static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts,
303                                          MacroBuilder &Builder) {
304   Builder.defineMacro("_GLIBCXX_PREDEFINED_OBJC_ARC_IS_SCALAR");
305 
306   std::string Result;
307   {
308     // Provide specializations for the __is_scalar type trait so that
309     // lifetime-qualified objects are not considered "scalar" types, which
310     // libstdc++ uses as an indicator of the presence of trivial copy, assign,
311     // default-construct, and destruct semantics (none of which hold for
312     // lifetime-qualified objects in ARC).
313     llvm::raw_string_ostream Out(Result);
314 
315     Out << "namespace std {\n"
316         << "\n"
317         << "struct __true_type;\n"
318         << "struct __false_type;\n"
319         << "\n";
320 
321     Out << "template<typename _Tp> struct __is_scalar;\n"
322         << "\n";
323 
324     Out << "template<typename _Tp>\n"
325         << "struct __is_scalar<__attribute__((objc_ownership(strong))) _Tp> {\n"
326         << "  enum { __value = 0 };\n"
327         << "  typedef __false_type __type;\n"
328         << "};\n"
329         << "\n";
330 
331     if (LangOpts.ObjCARCWeak) {
332       Out << "template<typename _Tp>\n"
333           << "struct __is_scalar<__attribute__((objc_ownership(weak))) _Tp> {\n"
334           << "  enum { __value = 0 };\n"
335           << "  typedef __false_type __type;\n"
336           << "};\n"
337           << "\n";
338     }
339 
340     Out << "template<typename _Tp>\n"
341         << "struct __is_scalar<__attribute__((objc_ownership(autoreleasing)))"
342         << " _Tp> {\n"
343         << "  enum { __value = 0 };\n"
344         << "  typedef __false_type __type;\n"
345         << "};\n"
346         << "\n";
347 
348     Out << "}\n";
349   }
350   Builder.append(Result);
351 }
352 
InitializeStandardPredefinedMacros(const TargetInfo & TI,const LangOptions & LangOpts,const FrontendOptions & FEOpts,MacroBuilder & Builder)353 static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
354                                                const LangOptions &LangOpts,
355                                                const FrontendOptions &FEOpts,
356                                                MacroBuilder &Builder) {
357   if (!LangOpts.MSVCCompat && !LangOpts.TraditionalCPP)
358     Builder.defineMacro("__STDC__");
359   if (LangOpts.Freestanding)
360     Builder.defineMacro("__STDC_HOSTED__", "0");
361   else
362     Builder.defineMacro("__STDC_HOSTED__");
363 
364   if (!LangOpts.CPlusPlus) {
365     if (LangOpts.C11)
366       Builder.defineMacro("__STDC_VERSION__", "201112L");
367     else if (LangOpts.C99)
368       Builder.defineMacro("__STDC_VERSION__", "199901L");
369     else if (!LangOpts.GNUMode && LangOpts.Digraphs)
370       Builder.defineMacro("__STDC_VERSION__", "199409L");
371   } else {
372     // FIXME: Use correct value for C++17.
373     if (LangOpts.CPlusPlus1z)
374       Builder.defineMacro("__cplusplus", "201406L");
375     // C++1y [cpp.predefined]p1:
376     //   The name __cplusplus is defined to the value 201402L when compiling a
377     //   C++ translation unit.
378     else if (LangOpts.CPlusPlus14)
379       Builder.defineMacro("__cplusplus", "201402L");
380     // C++11 [cpp.predefined]p1:
381     //   The name __cplusplus is defined to the value 201103L when compiling a
382     //   C++ translation unit.
383     else if (LangOpts.CPlusPlus11)
384       Builder.defineMacro("__cplusplus", "201103L");
385     // C++03 [cpp.predefined]p1:
386     //   The name __cplusplus is defined to the value 199711L when compiling a
387     //   C++ translation unit.
388     else
389       Builder.defineMacro("__cplusplus", "199711L");
390   }
391 
392   // In C11 these are environment macros. In C++11 they are only defined
393   // as part of <cuchar>. To prevent breakage when mixing C and C++
394   // code, define these macros unconditionally. We can define them
395   // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit
396   // and 32-bit character literals.
397   Builder.defineMacro("__STDC_UTF_16__", "1");
398   Builder.defineMacro("__STDC_UTF_32__", "1");
399 
400   if (LangOpts.ObjC1)
401     Builder.defineMacro("__OBJC__");
402 
403   // Not "standard" per se, but available even with the -undef flag.
404   if (LangOpts.AsmPreprocessor)
405     Builder.defineMacro("__ASSEMBLER__");
406 }
407 
408 /// Initialize the predefined C++ language feature test macros defined in
409 /// ISO/IEC JTC1/SC22/WG21 (C++) SD-6: "SG10 Feature Test Recommendations".
InitializeCPlusPlusFeatureTestMacros(const LangOptions & LangOpts,MacroBuilder & Builder)410 static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
411                                                  MacroBuilder &Builder) {
412   // C++98 features.
413   if (LangOpts.RTTI)
414     Builder.defineMacro("__cpp_rtti", "199711");
415   if (LangOpts.CXXExceptions)
416     Builder.defineMacro("__cpp_exceptions", "199711");
417 
418   // C++11 features.
419   if (LangOpts.CPlusPlus11) {
420     Builder.defineMacro("__cpp_unicode_characters", "200704");
421     Builder.defineMacro("__cpp_raw_strings", "200710");
422     Builder.defineMacro("__cpp_unicode_literals", "200710");
423     Builder.defineMacro("__cpp_user_defined_literals", "200809");
424     Builder.defineMacro("__cpp_lambdas", "200907");
425     Builder.defineMacro("__cpp_constexpr",
426                         LangOpts.CPlusPlus14 ? "201304" : "200704");
427     Builder.defineMacro("__cpp_range_based_for", "200907");
428     Builder.defineMacro("__cpp_static_assert", "200410");
429     Builder.defineMacro("__cpp_decltype", "200707");
430     Builder.defineMacro("__cpp_attributes", "200809");
431     Builder.defineMacro("__cpp_rvalue_references", "200610");
432     Builder.defineMacro("__cpp_variadic_templates", "200704");
433     Builder.defineMacro("__cpp_initializer_lists", "200806");
434     Builder.defineMacro("__cpp_delegating_constructors", "200604");
435     Builder.defineMacro("__cpp_nsdmi", "200809");
436     Builder.defineMacro("__cpp_inheriting_constructors", "200802");
437     Builder.defineMacro("__cpp_ref_qualifiers", "200710");
438     Builder.defineMacro("__cpp_alias_templates", "200704");
439   }
440 
441   // C++14 features.
442   if (LangOpts.CPlusPlus14) {
443     Builder.defineMacro("__cpp_binary_literals", "201304");
444     Builder.defineMacro("__cpp_digit_separators", "201309");
445     Builder.defineMacro("__cpp_init_captures", "201304");
446     Builder.defineMacro("__cpp_generic_lambdas", "201304");
447     Builder.defineMacro("__cpp_decltype_auto", "201304");
448     Builder.defineMacro("__cpp_return_type_deduction", "201304");
449     Builder.defineMacro("__cpp_aggregate_nsdmi", "201304");
450     Builder.defineMacro("__cpp_variable_templates", "201304");
451   }
452   if (LangOpts.SizedDeallocation)
453     Builder.defineMacro("__cpp_sized_deallocation", "201309");
454 }
455 
InitializePredefinedMacros(const TargetInfo & TI,const LangOptions & LangOpts,const FrontendOptions & FEOpts,MacroBuilder & Builder)456 static void InitializePredefinedMacros(const TargetInfo &TI,
457                                        const LangOptions &LangOpts,
458                                        const FrontendOptions &FEOpts,
459                                        MacroBuilder &Builder) {
460   // Compiler version introspection macros.
461   Builder.defineMacro("__llvm__");  // LLVM Backend
462   Builder.defineMacro("__clang__"); // Clang Frontend
463 #define TOSTR2(X) #X
464 #define TOSTR(X) TOSTR2(X)
465   Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR));
466   Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR));
467 #ifdef CLANG_VERSION_PATCHLEVEL
468   Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL));
469 #else
470   Builder.defineMacro("__clang_patchlevel__", "0");
471 #endif
472   Builder.defineMacro("__clang_version__",
473                       "\"" CLANG_VERSION_STRING " "
474                       + getClangFullRepositoryVersion() + "\"");
475 #undef TOSTR
476 #undef TOSTR2
477   if (!LangOpts.MSVCCompat) {
478     // Currently claim to be compatible with GCC 4.2.1-5621, but only if we're
479     // not compiling for MSVC compatibility
480     Builder.defineMacro("__GNUC_MINOR__", "2");
481     Builder.defineMacro("__GNUC_PATCHLEVEL__", "1");
482     Builder.defineMacro("__GNUC__", "4");
483     Builder.defineMacro("__GXX_ABI_VERSION", "1002");
484   }
485 
486   // Define macros for the C11 / C++11 memory orderings
487   Builder.defineMacro("__ATOMIC_RELAXED", "0");
488   Builder.defineMacro("__ATOMIC_CONSUME", "1");
489   Builder.defineMacro("__ATOMIC_ACQUIRE", "2");
490   Builder.defineMacro("__ATOMIC_RELEASE", "3");
491   Builder.defineMacro("__ATOMIC_ACQ_REL", "4");
492   Builder.defineMacro("__ATOMIC_SEQ_CST", "5");
493 
494   // Support for #pragma redefine_extname (Sun compatibility)
495   Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");
496 
497   // As sad as it is, enough software depends on the __VERSION__ for version
498   // checks that it is necessary to report 4.2.1 (the base GCC version we claim
499   // compatibility with) first.
500   Builder.defineMacro("__VERSION__", "\"4.2.1 Compatible " +
501                       Twine(getClangFullCPPVersion()) + "\"");
502 
503   // Initialize language-specific preprocessor defines.
504 
505   // Standard conforming mode?
506   if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)
507     Builder.defineMacro("__STRICT_ANSI__");
508 
509   if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus11)
510     Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");
511 
512   if (LangOpts.ObjC1) {
513     if (LangOpts.ObjCRuntime.isNonFragile()) {
514       Builder.defineMacro("__OBJC2__");
515 
516       if (LangOpts.ObjCExceptions)
517         Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS");
518     }
519 
520     if (LangOpts.getGC() != LangOptions::NonGC)
521       Builder.defineMacro("__OBJC_GC__");
522 
523     if (LangOpts.ObjCRuntime.isNeXTFamily())
524       Builder.defineMacro("__NEXT_RUNTIME__");
525 
526     if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::ObjFW) {
527       VersionTuple tuple = LangOpts.ObjCRuntime.getVersion();
528 
529       unsigned minor = 0;
530       if (tuple.getMinor().hasValue())
531         minor = tuple.getMinor().getValue();
532 
533       unsigned subminor = 0;
534       if (tuple.getSubminor().hasValue())
535         subminor = tuple.getSubminor().getValue();
536 
537       Builder.defineMacro("__OBJFW_RUNTIME_ABI__",
538                           Twine(tuple.getMajor() * 10000 + minor * 100 +
539                                 subminor));
540     }
541 
542     Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))");
543     Builder.defineMacro("IBOutletCollection(ClassName)",
544                         "__attribute__((iboutletcollection(ClassName)))");
545     Builder.defineMacro("IBAction", "void)__attribute__((ibaction)");
546     Builder.defineMacro("IBInspectable", "");
547     Builder.defineMacro("IB_DESIGNABLE", "");
548   }
549 
550   if (LangOpts.CPlusPlus)
551     InitializeCPlusPlusFeatureTestMacros(LangOpts, Builder);
552 
553   // darwin_constant_cfstrings controls this. This is also dependent
554   // on other things like the runtime I believe.  This is set even for C code.
555   if (!LangOpts.NoConstantCFStrings)
556       Builder.defineMacro("__CONSTANT_CFSTRINGS__");
557 
558   if (LangOpts.ObjC2)
559     Builder.defineMacro("OBJC_NEW_PROPERTIES");
560 
561   if (LangOpts.PascalStrings)
562     Builder.defineMacro("__PASCAL_STRINGS__");
563 
564   if (LangOpts.Blocks) {
565     Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");
566     Builder.defineMacro("__BLOCKS__");
567   }
568 
569   if (!LangOpts.MSVCCompat && LangOpts.Exceptions)
570     Builder.defineMacro("__EXCEPTIONS");
571   if (!LangOpts.MSVCCompat && LangOpts.RTTI)
572     Builder.defineMacro("__GXX_RTTI");
573   if (LangOpts.SjLjExceptions)
574     Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
575 
576   if (LangOpts.Deprecated)
577     Builder.defineMacro("__DEPRECATED");
578 
579   if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus) {
580     Builder.defineMacro("__GNUG__", "4");
581     Builder.defineMacro("__GXX_WEAK__");
582     Builder.defineMacro("__private_extern__", "extern");
583   }
584 
585   if (LangOpts.MicrosoftExt) {
586     if (LangOpts.WChar) {
587       // wchar_t supported as a keyword.
588       Builder.defineMacro("_WCHAR_T_DEFINED");
589       Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED");
590     }
591   }
592 
593   if (LangOpts.Optimize)
594     Builder.defineMacro("__OPTIMIZE__");
595   if (LangOpts.OptimizeSize)
596     Builder.defineMacro("__OPTIMIZE_SIZE__");
597 
598   if (LangOpts.FastMath)
599     Builder.defineMacro("__FAST_MATH__");
600 
601   // Initialize target-specific preprocessor defines.
602 
603   // __BYTE_ORDER__ was added in GCC 4.6. It's analogous
604   // to the macro __BYTE_ORDER (no trailing underscores)
605   // from glibc's <endian.h> header.
606   // We don't support the PDP-11 as a target, but include
607   // the define so it can still be compared against.
608   Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234");
609   Builder.defineMacro("__ORDER_BIG_ENDIAN__",    "4321");
610   Builder.defineMacro("__ORDER_PDP_ENDIAN__",    "3412");
611   if (TI.isBigEndian()) {
612     Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__");
613     Builder.defineMacro("__BIG_ENDIAN__");
614   } else {
615     Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__");
616     Builder.defineMacro("__LITTLE_ENDIAN__");
617   }
618 
619   if (TI.getPointerWidth(0) == 64 && TI.getLongWidth() == 64
620       && TI.getIntWidth() == 32) {
621     Builder.defineMacro("_LP64");
622     Builder.defineMacro("__LP64__");
623   }
624 
625   if (TI.getPointerWidth(0) == 32 && TI.getLongWidth() == 32
626       && TI.getIntWidth() == 32) {
627     Builder.defineMacro("_ILP32");
628     Builder.defineMacro("__ILP32__");
629   }
630 
631   // Define type sizing macros based on the target properties.
632   assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");
633   Builder.defineMacro("__CHAR_BIT__", "8");
634 
635   DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder);
636   DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder);
637   DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder);
638   DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder);
639   DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder);
640   DefineTypeSize("__WCHAR_MAX__", TI.getWCharType(), TI, Builder);
641   DefineTypeSize("__INTMAX_MAX__", TI.getIntMaxType(), TI, Builder);
642   DefineTypeSize("__SIZE_MAX__", TI.getSizeType(), TI, Builder);
643 
644   DefineTypeSize("__UINTMAX_MAX__", TI.getUIntMaxType(), TI, Builder);
645   DefineTypeSize("__PTRDIFF_MAX__", TI.getPtrDiffType(0), TI, Builder);
646   DefineTypeSize("__INTPTR_MAX__", TI.getIntPtrType(), TI, Builder);
647   DefineTypeSize("__UINTPTR_MAX__", TI.getUIntPtrType(), TI, Builder);
648 
649   DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder);
650   DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder);
651   DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder);
652   DefineTypeSizeof("__SIZEOF_LONG__", TI.getLongWidth(), TI, Builder);
653   DefineTypeSizeof("__SIZEOF_LONG_DOUBLE__",TI.getLongDoubleWidth(),TI,Builder);
654   DefineTypeSizeof("__SIZEOF_LONG_LONG__", TI.getLongLongWidth(), TI, Builder);
655   DefineTypeSizeof("__SIZEOF_POINTER__", TI.getPointerWidth(0), TI, Builder);
656   DefineTypeSizeof("__SIZEOF_SHORT__", TI.getShortWidth(), TI, Builder);
657   DefineTypeSizeof("__SIZEOF_PTRDIFF_T__",
658                    TI.getTypeWidth(TI.getPtrDiffType(0)), TI, Builder);
659   DefineTypeSizeof("__SIZEOF_SIZE_T__",
660                    TI.getTypeWidth(TI.getSizeType()), TI, Builder);
661   DefineTypeSizeof("__SIZEOF_WCHAR_T__",
662                    TI.getTypeWidth(TI.getWCharType()), TI, Builder);
663   DefineTypeSizeof("__SIZEOF_WINT_T__",
664                    TI.getTypeWidth(TI.getWIntType()), TI, Builder);
665   if (TI.hasInt128Type())
666     DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder);
667 
668   DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder);
669   DefineFmt("__INTMAX", TI.getIntMaxType(), TI, Builder);
670   Builder.defineMacro("__INTMAX_C_SUFFIX__",
671                       TI.getTypeConstantSuffix(TI.getIntMaxType()));
672   DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder);
673   DefineFmt("__UINTMAX", TI.getUIntMaxType(), TI, Builder);
674   Builder.defineMacro("__UINTMAX_C_SUFFIX__",
675                       TI.getTypeConstantSuffix(TI.getUIntMaxType()));
676   DefineTypeWidth("__INTMAX_WIDTH__",  TI.getIntMaxType(), TI, Builder);
677   DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Builder);
678   DefineFmt("__PTRDIFF", TI.getPtrDiffType(0), TI, Builder);
679   DefineTypeWidth("__PTRDIFF_WIDTH__", TI.getPtrDiffType(0), TI, Builder);
680   DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder);
681   DefineFmt("__INTPTR", TI.getIntPtrType(), TI, Builder);
682   DefineTypeWidth("__INTPTR_WIDTH__", TI.getIntPtrType(), TI, Builder);
683   DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder);
684   DefineFmt("__SIZE", TI.getSizeType(), TI, Builder);
685   DefineTypeWidth("__SIZE_WIDTH__", TI.getSizeType(), TI, Builder);
686   DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder);
687   DefineTypeWidth("__WCHAR_WIDTH__", TI.getWCharType(), TI, Builder);
688   DefineType("__WINT_TYPE__", TI.getWIntType(), Builder);
689   DefineTypeWidth("__WINT_WIDTH__", TI.getWIntType(), TI, Builder);
690   DefineTypeWidth("__SIG_ATOMIC_WIDTH__", TI.getSigAtomicType(), TI, Builder);
691   DefineTypeSize("__SIG_ATOMIC_MAX__", TI.getSigAtomicType(), TI, Builder);
692   DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder);
693   DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder);
694 
695   DefineTypeWidth("__UINTMAX_WIDTH__",  TI.getUIntMaxType(), TI, Builder);
696   DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder);
697   DefineFmt("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
698   DefineTypeWidth("__UINTPTR_WIDTH__", TI.getUIntPtrType(), TI, Builder);
699 
700   DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
701   DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
702   DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
703 
704   // Define a __POINTER_WIDTH__ macro for stdint.h.
705   Builder.defineMacro("__POINTER_WIDTH__",
706                       Twine((int)TI.getPointerWidth(0)));
707 
708   if (!LangOpts.CharIsSigned)
709     Builder.defineMacro("__CHAR_UNSIGNED__");
710 
711   if (!TargetInfo::isTypeSigned(TI.getWCharType()))
712     Builder.defineMacro("__WCHAR_UNSIGNED__");
713 
714   if (!TargetInfo::isTypeSigned(TI.getWIntType()))
715     Builder.defineMacro("__WINT_UNSIGNED__");
716 
717   // Define exact-width integer types for stdint.h
718   DefineExactWidthIntType(TargetInfo::SignedChar, TI, Builder);
719 
720   if (TI.getShortWidth() > TI.getCharWidth())
721     DefineExactWidthIntType(TargetInfo::SignedShort, TI, Builder);
722 
723   if (TI.getIntWidth() > TI.getShortWidth())
724     DefineExactWidthIntType(TargetInfo::SignedInt, TI, Builder);
725 
726   if (TI.getLongWidth() > TI.getIntWidth())
727     DefineExactWidthIntType(TargetInfo::SignedLong, TI, Builder);
728 
729   if (TI.getLongLongWidth() > TI.getLongWidth())
730     DefineExactWidthIntType(TargetInfo::SignedLongLong, TI, Builder);
731 
732   DefineExactWidthIntType(TargetInfo::UnsignedChar, TI, Builder);
733   DefineExactWidthIntTypeSize(TargetInfo::UnsignedChar, TI, Builder);
734   DefineExactWidthIntTypeSize(TargetInfo::SignedChar, TI, Builder);
735 
736   if (TI.getShortWidth() > TI.getCharWidth()) {
737     DefineExactWidthIntType(TargetInfo::UnsignedShort, TI, Builder);
738     DefineExactWidthIntTypeSize(TargetInfo::UnsignedShort, TI, Builder);
739     DefineExactWidthIntTypeSize(TargetInfo::SignedShort, TI, Builder);
740   }
741 
742   if (TI.getIntWidth() > TI.getShortWidth()) {
743     DefineExactWidthIntType(TargetInfo::UnsignedInt, TI, Builder);
744     DefineExactWidthIntTypeSize(TargetInfo::UnsignedInt, TI, Builder);
745     DefineExactWidthIntTypeSize(TargetInfo::SignedInt, TI, Builder);
746   }
747 
748   if (TI.getLongWidth() > TI.getIntWidth()) {
749     DefineExactWidthIntType(TargetInfo::UnsignedLong, TI, Builder);
750     DefineExactWidthIntTypeSize(TargetInfo::UnsignedLong, TI, Builder);
751     DefineExactWidthIntTypeSize(TargetInfo::SignedLong, TI, Builder);
752   }
753 
754   if (TI.getLongLongWidth() > TI.getLongWidth()) {
755     DefineExactWidthIntType(TargetInfo::UnsignedLongLong, TI, Builder);
756     DefineExactWidthIntTypeSize(TargetInfo::UnsignedLongLong, TI, Builder);
757     DefineExactWidthIntTypeSize(TargetInfo::SignedLongLong, TI, Builder);
758   }
759 
760   DefineLeastWidthIntType(8, true, TI, Builder);
761   DefineLeastWidthIntType(8, false, TI, Builder);
762   DefineLeastWidthIntType(16, true, TI, Builder);
763   DefineLeastWidthIntType(16, false, TI, Builder);
764   DefineLeastWidthIntType(32, true, TI, Builder);
765   DefineLeastWidthIntType(32, false, TI, Builder);
766   DefineLeastWidthIntType(64, true, TI, Builder);
767   DefineLeastWidthIntType(64, false, TI, Builder);
768 
769   DefineFastIntType(8, true, TI, Builder);
770   DefineFastIntType(8, false, TI, Builder);
771   DefineFastIntType(16, true, TI, Builder);
772   DefineFastIntType(16, false, TI, Builder);
773   DefineFastIntType(32, true, TI, Builder);
774   DefineFastIntType(32, false, TI, Builder);
775   DefineFastIntType(64, true, TI, Builder);
776   DefineFastIntType(64, false, TI, Builder);
777 
778   if (const char *Prefix = TI.getUserLabelPrefix())
779     Builder.defineMacro("__USER_LABEL_PREFIX__", Prefix);
780 
781   if (LangOpts.FastMath || LangOpts.FiniteMathOnly)
782     Builder.defineMacro("__FINITE_MATH_ONLY__", "1");
783   else
784     Builder.defineMacro("__FINITE_MATH_ONLY__", "0");
785 
786   if (!LangOpts.MSVCCompat) {
787     if (LangOpts.GNUInline)
788       Builder.defineMacro("__GNUC_GNU_INLINE__");
789     else
790       Builder.defineMacro("__GNUC_STDC_INLINE__");
791 
792     // The value written by __atomic_test_and_set.
793     // FIXME: This is target-dependent.
794     Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
795 
796     // Used by libstdc++ to implement ATOMIC_<foo>_LOCK_FREE.
797     unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth();
798 #define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \
799     Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \
800                         getLockFreeValue(TI.get##Type##Width(), \
801                                          TI.get##Type##Align(), \
802                                          InlineWidthBits));
803     DEFINE_LOCK_FREE_MACRO(BOOL, Bool);
804     DEFINE_LOCK_FREE_MACRO(CHAR, Char);
805     DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16);
806     DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32);
807     DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar);
808     DEFINE_LOCK_FREE_MACRO(SHORT, Short);
809     DEFINE_LOCK_FREE_MACRO(INT, Int);
810     DEFINE_LOCK_FREE_MACRO(LONG, Long);
811     DEFINE_LOCK_FREE_MACRO(LLONG, LongLong);
812     Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE",
813                         getLockFreeValue(TI.getPointerWidth(0),
814                                          TI.getPointerAlign(0),
815                                          InlineWidthBits));
816 #undef DEFINE_LOCK_FREE_MACRO
817   }
818 
819   if (LangOpts.NoInlineDefine)
820     Builder.defineMacro("__NO_INLINE__");
821 
822   if (unsigned PICLevel = LangOpts.PICLevel) {
823     Builder.defineMacro("__PIC__", Twine(PICLevel));
824     Builder.defineMacro("__pic__", Twine(PICLevel));
825   }
826   if (unsigned PIELevel = LangOpts.PIELevel) {
827     Builder.defineMacro("__PIE__", Twine(PIELevel));
828     Builder.defineMacro("__pie__", Twine(PIELevel));
829   }
830 
831   // Macros to control C99 numerics and <float.h>
832   Builder.defineMacro("__FLT_EVAL_METHOD__", Twine(TI.getFloatEvalMethod()));
833   Builder.defineMacro("__FLT_RADIX__", "2");
834   int Dig = PickFP(&TI.getLongDoubleFormat(), -1/*FIXME*/, 17, 21, 33, 36);
835   Builder.defineMacro("__DECIMAL_DIG__", Twine(Dig));
836 
837   if (LangOpts.getStackProtector() == LangOptions::SSPOn)
838     Builder.defineMacro("__SSP__");
839   else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
840     Builder.defineMacro("__SSP_STRONG__", "2");
841   else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
842     Builder.defineMacro("__SSP_ALL__", "3");
843 
844   if (FEOpts.ProgramAction == frontend::RewriteObjC)
845     Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
846 
847   // Define a macro that exists only when using the static analyzer.
848   if (FEOpts.ProgramAction == frontend::RunAnalysis)
849     Builder.defineMacro("__clang_analyzer__");
850 
851   if (LangOpts.FastRelaxedMath)
852     Builder.defineMacro("__FAST_RELAXED_MATH__");
853 
854   if (LangOpts.ObjCAutoRefCount) {
855     Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))");
856     Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))");
857     Builder.defineMacro("__autoreleasing",
858                         "__attribute__((objc_ownership(autoreleasing)))");
859     Builder.defineMacro("__unsafe_unretained",
860                         "__attribute__((objc_ownership(none)))");
861   }
862 
863   // OpenMP definition
864   if (LangOpts.OpenMP) {
865     // OpenMP 2.2:
866     //   In implementations that support a preprocessor, the _OPENMP
867     //   macro name is defined to have the decimal value yyyymm where
868     //   yyyy and mm are the year and the month designations of the
869     //   version of the OpenMP API that the implementation support.
870     Builder.defineMacro("_OPENMP", "201307");
871   }
872 
873   // CUDA device path compilaton
874   if (LangOpts.CUDAIsDevice) {
875     // The CUDA_ARCH value is set for the GPU target specified in the NVPTX
876     // backend's target defines.
877     Builder.defineMacro("__CUDA_ARCH__");
878   }
879 
880   // Get other target #defines.
881   TI.getTargetDefines(LangOpts, Builder);
882 }
883 
884 /// InitializePreprocessor - Initialize the preprocessor getting it and the
885 /// environment ready to process a single file. This returns true on error.
886 ///
InitializePreprocessor(Preprocessor & PP,const PreprocessorOptions & InitOpts,const FrontendOptions & FEOpts)887 void clang::InitializePreprocessor(Preprocessor &PP,
888                                    const PreprocessorOptions &InitOpts,
889                                    const FrontendOptions &FEOpts) {
890   const LangOptions &LangOpts = PP.getLangOpts();
891   std::string PredefineBuffer;
892   PredefineBuffer.reserve(4080);
893   llvm::raw_string_ostream Predefines(PredefineBuffer);
894   MacroBuilder Builder(Predefines);
895 
896   // Emit line markers for various builtin sections of the file.  We don't do
897   // this in asm preprocessor mode, because "# 4" is not a line marker directive
898   // in this mode.
899   if (!PP.getLangOpts().AsmPreprocessor)
900     Builder.append("# 1 \"<built-in>\" 3");
901 
902   // Install things like __POWERPC__, __GNUC__, etc into the macro table.
903   if (InitOpts.UsePredefines) {
904     InitializePredefinedMacros(PP.getTargetInfo(), LangOpts, FEOpts, Builder);
905 
906     // Install definitions to make Objective-C++ ARC work well with various
907     // C++ Standard Library implementations.
908     if (LangOpts.ObjC1 && LangOpts.CPlusPlus && LangOpts.ObjCAutoRefCount) {
909       switch (InitOpts.ObjCXXARCStandardLibrary) {
910       case ARCXX_nolib:
911         case ARCXX_libcxx:
912         break;
913 
914       case ARCXX_libstdcxx:
915         AddObjCXXARCLibstdcxxDefines(LangOpts, Builder);
916         break;
917       }
918     }
919   }
920 
921   // Even with predefines off, some macros are still predefined.
922   // These should all be defined in the preprocessor according to the
923   // current language configuration.
924   InitializeStandardPredefinedMacros(PP.getTargetInfo(), PP.getLangOpts(),
925                                      FEOpts, Builder);
926 
927   // Add on the predefines from the driver.  Wrap in a #line directive to report
928   // that they come from the command line.
929   if (!PP.getLangOpts().AsmPreprocessor)
930     Builder.append("# 1 \"<command line>\" 1");
931 
932   // Process #define's and #undef's in the order they are given.
933   for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
934     if (InitOpts.Macros[i].second)  // isUndef
935       Builder.undefineMacro(InitOpts.Macros[i].first);
936     else
937       DefineBuiltinMacro(Builder, InitOpts.Macros[i].first,
938                          PP.getDiagnostics());
939   }
940 
941   // If -imacros are specified, include them now.  These are processed before
942   // any -include directives.
943   for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
944     AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i]);
945 
946   // Process -include-pch/-include-pth directives.
947   if (!InitOpts.ImplicitPCHInclude.empty())
948     AddImplicitIncludePCH(Builder, PP, InitOpts.ImplicitPCHInclude);
949   if (!InitOpts.ImplicitPTHInclude.empty())
950     AddImplicitIncludePTH(Builder, PP, InitOpts.ImplicitPTHInclude);
951 
952   // Process -include directives.
953   for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {
954     const std::string &Path = InitOpts.Includes[i];
955     AddImplicitInclude(Builder, Path);
956   }
957 
958   // Exit the command line and go back to <built-in> (2 is LC_LEAVE).
959   if (!PP.getLangOpts().AsmPreprocessor)
960     Builder.append("# 1 \"<built-in>\" 2");
961 
962   // Instruct the preprocessor to skip the preamble.
963   PP.setSkipMainFilePreamble(InitOpts.PrecompiledPreambleBytes.first,
964                              InitOpts.PrecompiledPreambleBytes.second);
965 
966   // Copy PredefinedBuffer into the Preprocessor.
967   PP.setPredefines(Predefines.str());
968 }
969