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