clang  3.8.0
InitPreprocessor.cpp
Go to the documentation of this file.
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"
18 #include "clang/Basic/TargetInfo.h"
19 #include "clang/Basic/Version.h"
22 #include "clang/Lex/HeaderSearch.h"
23 #include "clang/Lex/PTHManager.h"
24 #include "clang/Lex/Preprocessor.h"
27 #include "llvm/ADT/APFloat.h"
28 #include "llvm/Support/FileSystem.h"
29 #include "llvm/Support/MemoryBuffer.h"
30 #include "llvm/Support/Path.h"
31 using namespace clang;
32 
33 static bool MacroBodyEndsInBackslash(StringRef MacroBody) {
34  while (!MacroBody.empty() && isWhitespace(MacroBody.back()))
35  MacroBody = MacroBody.drop_back();
36  return !MacroBody.empty() && MacroBody.back() == '\\';
37 }
38 
39 // Append a #define line to Buf for Macro. Macro should be of the form XXX,
40 // in which case we emit "#define XXX 1" or "XXX=Y z W" in which case we emit
41 // "#define XXX Y z W". To get a #define with no value, use "XXX=".
42 static void DefineBuiltinMacro(MacroBuilder &Builder, StringRef Macro,
43  DiagnosticsEngine &Diags) {
44  std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
45  StringRef MacroName = MacroPair.first;
46  StringRef MacroBody = MacroPair.second;
47  if (MacroName.size() != Macro.size()) {
48  // Per GCC -D semantics, the macro ends at \n if it exists.
49  StringRef::size_type End = MacroBody.find_first_of("\n\r");
50  if (End != StringRef::npos)
51  Diags.Report(diag::warn_fe_macro_contains_embedded_newline)
52  << MacroName;
53  MacroBody = MacroBody.substr(0, End);
54  // We handle macro bodies which end in a backslash by appending an extra
55  // backslash+newline. This makes sure we don't accidentally treat the
56  // backslash as a line continuation marker.
57  if (MacroBodyEndsInBackslash(MacroBody))
58  Builder.defineMacro(MacroName, Twine(MacroBody) + "\\\n");
59  else
60  Builder.defineMacro(MacroName, MacroBody);
61  } else {
62  // Push "macroname 1".
63  Builder.defineMacro(Macro);
64  }
65 }
66 
67 /// AddImplicitInclude - Add an implicit \#include of the specified file to the
68 /// predefines buffer.
69 /// As these includes are generated by -include arguments the header search
70 /// logic is going to search relatively to the current working directory.
71 static void AddImplicitInclude(MacroBuilder &Builder, StringRef File) {
72  Builder.append(Twine("#include \"") + File + "\"");
73 }
74 
75 static void AddImplicitIncludeMacros(MacroBuilder &Builder, StringRef File) {
76  Builder.append(Twine("#__include_macros \"") + File + "\"");
77  // Marker token to stop the __include_macros fetch loop.
78  Builder.append("##"); // ##?
79 }
80 
81 /// AddImplicitIncludePTH - Add an implicit \#include using the original file
82 /// used to generate a PTH cache.
84  StringRef ImplicitIncludePTH) {
85  PTHManager *P = PP.getPTHManager();
86  // Null check 'P' in the corner case where it couldn't be created.
87  const char *OriginalFile = P ? P->getOriginalSourceFile() : nullptr;
88 
89  if (!OriginalFile) {
90  PP.getDiagnostics().Report(diag::err_fe_pth_file_has_no_source_header)
91  << ImplicitIncludePTH;
92  return;
93  }
94 
95  AddImplicitInclude(Builder, OriginalFile);
96 }
97 
98 /// \brief Add an implicit \#include using the original file used to generate
99 /// a PCH file.
101  const PCHContainerReader &PCHContainerRdr,
102  StringRef ImplicitIncludePCH) {
103  std::string OriginalFile =
104  ASTReader::getOriginalSourceFile(ImplicitIncludePCH, PP.getFileManager(),
105  PCHContainerRdr, PP.getDiagnostics());
106  if (OriginalFile.empty())
107  return;
108 
109  AddImplicitInclude(Builder, OriginalFile);
110 }
111 
112 /// PickFP - This is used to pick a value based on the FP semantics of the
113 /// specified FP model.
114 template <typename T>
115 static T PickFP(const llvm::fltSemantics *Sem, T IEEESingleVal,
116  T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal,
117  T IEEEQuadVal) {
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, "1.40129846e-45", "4.9406564584124654e-324",
134  "3.64519953188247460253e-4951",
135  "4.94065645841246544176568792868221e-324",
136  "6.47517511943802511092443895822764655e-4966");
137  int Digits = PickFP(Sem, 6, 15, 18, 31, 33);
138  int DecimalDigits = PickFP(Sem, 9, 17, 21, 33, 36);
139  Epsilon = PickFP(Sem, "1.19209290e-7", "2.2204460492503131e-16",
140  "1.08420217248550443401e-19",
141  "4.94065645841246544176568792868221e-324",
142  "1.92592994438723585305597794258492732e-34");
143  int MantissaDigits = PickFP(Sem, 24, 53, 64, 106, 113);
144  int Min10Exp = PickFP(Sem, -37, -307, -4931, -291, -4931);
145  int Max10Exp = PickFP(Sem, 38, 308, 4932, 308, 4932);
146  int MinExp = PickFP(Sem, -125, -1021, -16381, -968, -16381);
147  int MaxExp = PickFP(Sem, 128, 1024, 16384, 1024, 16384);
148  Min = PickFP(Sem, "1.17549435e-38", "2.2250738585072014e-308",
149  "3.36210314311209350626e-4932",
150  "2.00416836000897277799610805135016e-292",
151  "3.36210314311209350626267781732175260e-4932");
152  Max = PickFP(Sem, "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,
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,
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 
227  const TargetInfo &TI,
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 
247  const TargetInfo &TI,
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,
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,
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 
362  const LangOptions &LangOpts,
363  const FrontendOptions &FEOpts,
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.C11)
374  Builder.defineMacro("__STDC_VERSION__", "201112L");
375  else if (LangOpts.C99)
376  Builder.defineMacro("__STDC_VERSION__", "199901L");
377  else if (!LangOpts.GNUMode && LangOpts.Digraphs)
378  Builder.defineMacro("__STDC_VERSION__", "199409L");
379  } else {
380  // FIXME: Use correct value for C++17.
381  if (LangOpts.CPlusPlus1z)
382  Builder.defineMacro("__cplusplus", "201406L");
383  // C++1y [cpp.predefined]p1:
384  // The name __cplusplus is defined to the value 201402L when compiling a
385  // C++ translation unit.
386  else if (LangOpts.CPlusPlus14)
387  Builder.defineMacro("__cplusplus", "201402L");
388  // C++11 [cpp.predefined]p1:
389  // The name __cplusplus is defined to the value 201103L when compiling a
390  // C++ translation unit.
391  else if (LangOpts.CPlusPlus11)
392  Builder.defineMacro("__cplusplus", "201103L");
393  // C++03 [cpp.predefined]p1:
394  // The name __cplusplus is defined to the value 199711L when compiling a
395  // C++ translation unit.
396  else
397  Builder.defineMacro("__cplusplus", "199711L");
398  }
399 
400  // In C11 these are environment macros. In C++11 they are only defined
401  // as part of <cuchar>. To prevent breakage when mixing C and C++
402  // code, define these macros unconditionally. We can define them
403  // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit
404  // and 32-bit character literals.
405  Builder.defineMacro("__STDC_UTF_16__", "1");
406  Builder.defineMacro("__STDC_UTF_32__", "1");
407 
408  if (LangOpts.ObjC1)
409  Builder.defineMacro("__OBJC__");
410 
411  // Not "standard" per se, but available even with the -undef flag.
412  if (LangOpts.AsmPreprocessor)
413  Builder.defineMacro("__ASSEMBLER__");
414  if (LangOpts.CUDA)
415  Builder.defineMacro("__CUDA__");
416 }
417 
418 /// Initialize the predefined C++ language feature test macros defined in
419 /// ISO/IEC JTC1/SC22/WG21 (C++) SD-6: "SG10 Feature Test Recommendations".
422  // C++98 features.
423  if (LangOpts.RTTI)
424  Builder.defineMacro("__cpp_rtti", "199711");
425  if (LangOpts.CXXExceptions)
426  Builder.defineMacro("__cpp_exceptions", "199711");
427 
428  // C++11 features.
429  if (LangOpts.CPlusPlus11) {
430  Builder.defineMacro("__cpp_unicode_characters", "200704");
431  Builder.defineMacro("__cpp_raw_strings", "200710");
432  Builder.defineMacro("__cpp_unicode_literals", "200710");
433  Builder.defineMacro("__cpp_user_defined_literals", "200809");
434  Builder.defineMacro("__cpp_lambdas", "200907");
435  Builder.defineMacro("__cpp_constexpr",
436  LangOpts.CPlusPlus14 ? "201304" : "200704");
437  Builder.defineMacro("__cpp_range_based_for", "200907");
438  Builder.defineMacro("__cpp_static_assert", "200410");
439  Builder.defineMacro("__cpp_decltype", "200707");
440  Builder.defineMacro("__cpp_attributes", "200809");
441  Builder.defineMacro("__cpp_rvalue_references", "200610");
442  Builder.defineMacro("__cpp_variadic_templates", "200704");
443  Builder.defineMacro("__cpp_initializer_lists", "200806");
444  Builder.defineMacro("__cpp_delegating_constructors", "200604");
445  Builder.defineMacro("__cpp_nsdmi", "200809");
446  Builder.defineMacro("__cpp_inheriting_constructors", "200802");
447  Builder.defineMacro("__cpp_ref_qualifiers", "200710");
448  Builder.defineMacro("__cpp_alias_templates", "200704");
449  }
450 
451  // C++14 features.
452  if (LangOpts.CPlusPlus14) {
453  Builder.defineMacro("__cpp_binary_literals", "201304");
454  Builder.defineMacro("__cpp_digit_separators", "201309");
455  Builder.defineMacro("__cpp_init_captures", "201304");
456  Builder.defineMacro("__cpp_generic_lambdas", "201304");
457  Builder.defineMacro("__cpp_decltype_auto", "201304");
458  Builder.defineMacro("__cpp_return_type_deduction", "201304");
459  Builder.defineMacro("__cpp_aggregate_nsdmi", "201304");
460  Builder.defineMacro("__cpp_variable_templates", "201304");
461  }
462  if (LangOpts.SizedDeallocation)
463  Builder.defineMacro("__cpp_sized_deallocation", "201309");
464  if (LangOpts.ConceptsTS)
465  Builder.defineMacro("__cpp_experimental_concepts", "1");
466  if (LangOpts.Coroutines)
467  Builder.defineMacro("__cpp_coroutines", "1");
468 }
469 
471  const LangOptions &LangOpts,
472  const FrontendOptions &FEOpts,
474  // Compiler version introspection macros.
475  Builder.defineMacro("__llvm__"); // LLVM Backend
476  Builder.defineMacro("__clang__"); // Clang Frontend
477 #define TOSTR2(X) #X
478 #define TOSTR(X) TOSTR2(X)
479  Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR));
480  Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR));
481 #ifdef CLANG_VERSION_PATCHLEVEL
482  Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL));
483 #else
484  Builder.defineMacro("__clang_patchlevel__", "0");
485 #endif
486  Builder.defineMacro("__clang_version__",
487  "\"" CLANG_VERSION_STRING " "
488  + getClangFullRepositoryVersion() + "\"");
489 #undef TOSTR
490 #undef TOSTR2
491  if (!LangOpts.MSVCCompat) {
492  // Currently claim to be compatible with GCC 4.2.1-5621, but only if we're
493  // not compiling for MSVC compatibility
494  Builder.defineMacro("__GNUC_MINOR__", "2");
495  Builder.defineMacro("__GNUC_PATCHLEVEL__", "1");
496  Builder.defineMacro("__GNUC__", "4");
497  Builder.defineMacro("__GXX_ABI_VERSION", "1002");
498  }
499 
500  // Define macros for the C11 / C++11 memory orderings
501  Builder.defineMacro("__ATOMIC_RELAXED", "0");
502  Builder.defineMacro("__ATOMIC_CONSUME", "1");
503  Builder.defineMacro("__ATOMIC_ACQUIRE", "2");
504  Builder.defineMacro("__ATOMIC_RELEASE", "3");
505  Builder.defineMacro("__ATOMIC_ACQ_REL", "4");
506  Builder.defineMacro("__ATOMIC_SEQ_CST", "5");
507 
508  // Support for #pragma redefine_extname (Sun compatibility)
509  Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");
510 
511  // As sad as it is, enough software depends on the __VERSION__ for version
512  // checks that it is necessary to report 4.2.1 (the base GCC version we claim
513  // compatibility with) first.
514  Builder.defineMacro("__VERSION__", "\"4.2.1 Compatible " +
515  Twine(getClangFullCPPVersion()) + "\"");
516 
517  // Initialize language-specific preprocessor defines.
518 
519  // Standard conforming mode?
520  if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)
521  Builder.defineMacro("__STRICT_ANSI__");
522 
523  if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus11)
524  Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");
525 
526  if (LangOpts.ObjC1) {
527  if (LangOpts.ObjCRuntime.isNonFragile()) {
528  Builder.defineMacro("__OBJC2__");
529 
530  if (LangOpts.ObjCExceptions)
531  Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS");
532  }
533 
534  if (LangOpts.getGC() != LangOptions::NonGC)
535  Builder.defineMacro("__OBJC_GC__");
536 
537  if (LangOpts.ObjCRuntime.isNeXTFamily())
538  Builder.defineMacro("__NEXT_RUNTIME__");
539 
540  if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::ObjFW) {
541  VersionTuple tuple = LangOpts.ObjCRuntime.getVersion();
542 
543  unsigned minor = 0;
544  if (tuple.getMinor().hasValue())
545  minor = tuple.getMinor().getValue();
546 
547  unsigned subminor = 0;
548  if (tuple.getSubminor().hasValue())
549  subminor = tuple.getSubminor().getValue();
550 
551  Builder.defineMacro("__OBJFW_RUNTIME_ABI__",
552  Twine(tuple.getMajor() * 10000 + minor * 100 +
553  subminor));
554  }
555 
556  Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))");
557  Builder.defineMacro("IBOutletCollection(ClassName)",
558  "__attribute__((iboutletcollection(ClassName)))");
559  Builder.defineMacro("IBAction", "void)__attribute__((ibaction)");
560  Builder.defineMacro("IBInspectable", "");
561  Builder.defineMacro("IB_DESIGNABLE", "");
562  }
563 
564  if (LangOpts.CPlusPlus)
565  InitializeCPlusPlusFeatureTestMacros(LangOpts, Builder);
566 
567  // darwin_constant_cfstrings controls this. This is also dependent
568  // on other things like the runtime I believe. This is set even for C code.
569  if (!LangOpts.NoConstantCFStrings)
570  Builder.defineMacro("__CONSTANT_CFSTRINGS__");
571 
572  if (LangOpts.ObjC2)
573  Builder.defineMacro("OBJC_NEW_PROPERTIES");
574 
575  if (LangOpts.PascalStrings)
576  Builder.defineMacro("__PASCAL_STRINGS__");
577 
578  if (LangOpts.Blocks) {
579  Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");
580  Builder.defineMacro("__BLOCKS__");
581  }
582 
583  if (!LangOpts.MSVCCompat && LangOpts.Exceptions)
584  Builder.defineMacro("__EXCEPTIONS");
585  if (!LangOpts.MSVCCompat && LangOpts.RTTI)
586  Builder.defineMacro("__GXX_RTTI");
587  if (LangOpts.SjLjExceptions)
588  Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
589 
590  if (LangOpts.Deprecated)
591  Builder.defineMacro("__DEPRECATED");
592 
593  if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus) {
594  Builder.defineMacro("__GNUG__", "4");
595  Builder.defineMacro("__GXX_WEAK__");
596  Builder.defineMacro("__private_extern__", "extern");
597  }
598 
599  if (LangOpts.MicrosoftExt) {
600  if (LangOpts.WChar) {
601  // wchar_t supported as a keyword.
602  Builder.defineMacro("_WCHAR_T_DEFINED");
603  Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED");
604  }
605  }
606 
607  if (LangOpts.Optimize)
608  Builder.defineMacro("__OPTIMIZE__");
609  if (LangOpts.OptimizeSize)
610  Builder.defineMacro("__OPTIMIZE_SIZE__");
611 
612  if (LangOpts.FastMath)
613  Builder.defineMacro("__FAST_MATH__");
614 
615  // Initialize target-specific preprocessor defines.
616 
617  // __BYTE_ORDER__ was added in GCC 4.6. It's analogous
618  // to the macro __BYTE_ORDER (no trailing underscores)
619  // from glibc's <endian.h> header.
620  // We don't support the PDP-11 as a target, but include
621  // the define so it can still be compared against.
622  Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234");
623  Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321");
624  Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412");
625  if (TI.isBigEndian()) {
626  Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__");
627  Builder.defineMacro("__BIG_ENDIAN__");
628  } else {
629  Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__");
630  Builder.defineMacro("__LITTLE_ENDIAN__");
631  }
632 
633  if (TI.getPointerWidth(0) == 64 && TI.getLongWidth() == 64
634  && TI.getIntWidth() == 32) {
635  Builder.defineMacro("_LP64");
636  Builder.defineMacro("__LP64__");
637  }
638 
639  if (TI.getPointerWidth(0) == 32 && TI.getLongWidth() == 32
640  && TI.getIntWidth() == 32) {
641  Builder.defineMacro("_ILP32");
642  Builder.defineMacro("__ILP32__");
643  }
644 
645  // Define type sizing macros based on the target properties.
646  assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");
647  Builder.defineMacro("__CHAR_BIT__", "8");
648 
649  DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder);
650  DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder);
651  DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder);
652  DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder);
653  DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder);
654  DefineTypeSize("__WCHAR_MAX__", TI.getWCharType(), TI, Builder);
655  DefineTypeSize("__INTMAX_MAX__", TI.getIntMaxType(), TI, Builder);
656  DefineTypeSize("__SIZE_MAX__", TI.getSizeType(), TI, Builder);
657 
658  DefineTypeSize("__UINTMAX_MAX__", TI.getUIntMaxType(), TI, Builder);
659  DefineTypeSize("__PTRDIFF_MAX__", TI.getPtrDiffType(0), TI, Builder);
660  DefineTypeSize("__INTPTR_MAX__", TI.getIntPtrType(), TI, Builder);
661  DefineTypeSize("__UINTPTR_MAX__", TI.getUIntPtrType(), TI, Builder);
662 
663  DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder);
664  DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder);
665  DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder);
666  DefineTypeSizeof("__SIZEOF_LONG__", TI.getLongWidth(), TI, Builder);
667  DefineTypeSizeof("__SIZEOF_LONG_DOUBLE__",TI.getLongDoubleWidth(),TI,Builder);
668  DefineTypeSizeof("__SIZEOF_LONG_LONG__", TI.getLongLongWidth(), TI, Builder);
669  DefineTypeSizeof("__SIZEOF_POINTER__", TI.getPointerWidth(0), TI, Builder);
670  DefineTypeSizeof("__SIZEOF_SHORT__", TI.getShortWidth(), TI, Builder);
671  DefineTypeSizeof("__SIZEOF_PTRDIFF_T__",
672  TI.getTypeWidth(TI.getPtrDiffType(0)), TI, Builder);
673  DefineTypeSizeof("__SIZEOF_SIZE_T__",
674  TI.getTypeWidth(TI.getSizeType()), TI, Builder);
675  DefineTypeSizeof("__SIZEOF_WCHAR_T__",
676  TI.getTypeWidth(TI.getWCharType()), TI, Builder);
677  DefineTypeSizeof("__SIZEOF_WINT_T__",
678  TI.getTypeWidth(TI.getWIntType()), TI, Builder);
679  if (TI.hasInt128Type())
680  DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder);
681 
682  DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder);
683  DefineFmt("__INTMAX", TI.getIntMaxType(), TI, Builder);
684  Builder.defineMacro("__INTMAX_C_SUFFIX__",
686  DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder);
687  DefineFmt("__UINTMAX", TI.getUIntMaxType(), TI, Builder);
688  Builder.defineMacro("__UINTMAX_C_SUFFIX__",
690  DefineTypeWidth("__INTMAX_WIDTH__", TI.getIntMaxType(), TI, Builder);
691  DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Builder);
692  DefineFmt("__PTRDIFF", TI.getPtrDiffType(0), TI, Builder);
693  DefineTypeWidth("__PTRDIFF_WIDTH__", TI.getPtrDiffType(0), TI, Builder);
694  DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder);
695  DefineFmt("__INTPTR", TI.getIntPtrType(), TI, Builder);
696  DefineTypeWidth("__INTPTR_WIDTH__", TI.getIntPtrType(), TI, Builder);
697  DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder);
698  DefineFmt("__SIZE", TI.getSizeType(), TI, Builder);
699  DefineTypeWidth("__SIZE_WIDTH__", TI.getSizeType(), TI, Builder);
700  DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder);
701  DefineTypeWidth("__WCHAR_WIDTH__", TI.getWCharType(), TI, Builder);
702  DefineType("__WINT_TYPE__", TI.getWIntType(), Builder);
703  DefineTypeWidth("__WINT_WIDTH__", TI.getWIntType(), TI, Builder);
704  DefineTypeWidth("__SIG_ATOMIC_WIDTH__", TI.getSigAtomicType(), TI, Builder);
705  DefineTypeSize("__SIG_ATOMIC_MAX__", TI.getSigAtomicType(), TI, Builder);
706  DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder);
707  DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder);
708 
709  DefineTypeWidth("__UINTMAX_WIDTH__", TI.getUIntMaxType(), TI, Builder);
710  DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder);
711  DefineFmt("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
712  DefineTypeWidth("__UINTPTR_WIDTH__", TI.getUIntPtrType(), TI, Builder);
713 
714  DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
715  DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
716  DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
717 
718  // Define a __POINTER_WIDTH__ macro for stdint.h.
719  Builder.defineMacro("__POINTER_WIDTH__",
720  Twine((int)TI.getPointerWidth(0)));
721 
722  // Define __BIGGEST_ALIGNMENT__ to be compatible with gcc.
723  Builder.defineMacro("__BIGGEST_ALIGNMENT__",
724  Twine(TI.getSuitableAlign() / TI.getCharWidth()) );
725 
726  if (!LangOpts.CharIsSigned)
727  Builder.defineMacro("__CHAR_UNSIGNED__");
728 
730  Builder.defineMacro("__WCHAR_UNSIGNED__");
731 
733  Builder.defineMacro("__WINT_UNSIGNED__");
734 
735  // Define exact-width integer types for stdint.h
737 
738  if (TI.getShortWidth() > TI.getCharWidth())
740 
741  if (TI.getIntWidth() > TI.getShortWidth())
743 
744  if (TI.getLongWidth() > TI.getIntWidth())
746 
747  if (TI.getLongLongWidth() > TI.getLongWidth())
749 
753 
754  if (TI.getShortWidth() > TI.getCharWidth()) {
758  }
759 
760  if (TI.getIntWidth() > TI.getShortWidth()) {
764  }
765 
766  if (TI.getLongWidth() > TI.getIntWidth()) {
770  }
771 
772  if (TI.getLongLongWidth() > TI.getLongWidth()) {
776  }
777 
778  DefineLeastWidthIntType(8, true, TI, Builder);
779  DefineLeastWidthIntType(8, false, TI, Builder);
780  DefineLeastWidthIntType(16, true, TI, Builder);
781  DefineLeastWidthIntType(16, false, TI, Builder);
782  DefineLeastWidthIntType(32, true, TI, Builder);
783  DefineLeastWidthIntType(32, false, TI, Builder);
784  DefineLeastWidthIntType(64, true, TI, Builder);
785  DefineLeastWidthIntType(64, false, TI, Builder);
786 
787  DefineFastIntType(8, true, TI, Builder);
788  DefineFastIntType(8, false, TI, Builder);
789  DefineFastIntType(16, true, TI, Builder);
790  DefineFastIntType(16, false, TI, Builder);
791  DefineFastIntType(32, true, TI, Builder);
792  DefineFastIntType(32, false, TI, Builder);
793  DefineFastIntType(64, true, TI, Builder);
794  DefineFastIntType(64, false, TI, Builder);
795 
796  if (const char *Prefix = TI.getUserLabelPrefix())
797  Builder.defineMacro("__USER_LABEL_PREFIX__", Prefix);
798 
799  if (LangOpts.FastMath || LangOpts.FiniteMathOnly)
800  Builder.defineMacro("__FINITE_MATH_ONLY__", "1");
801  else
802  Builder.defineMacro("__FINITE_MATH_ONLY__", "0");
803 
804  if (!LangOpts.MSVCCompat) {
805  if (LangOpts.GNUInline || LangOpts.CPlusPlus)
806  Builder.defineMacro("__GNUC_GNU_INLINE__");
807  else
808  Builder.defineMacro("__GNUC_STDC_INLINE__");
809 
810  // The value written by __atomic_test_and_set.
811  // FIXME: This is target-dependent.
812  Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
813 
814  // Used by libstdc++ to implement ATOMIC_<foo>_LOCK_FREE.
815  unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth();
816 #define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \
817  Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \
818  getLockFreeValue(TI.get##Type##Width(), \
819  TI.get##Type##Align(), \
820  InlineWidthBits));
821  DEFINE_LOCK_FREE_MACRO(BOOL, Bool);
822  DEFINE_LOCK_FREE_MACRO(CHAR, Char);
823  DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16);
824  DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32);
825  DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar);
826  DEFINE_LOCK_FREE_MACRO(SHORT, Short);
827  DEFINE_LOCK_FREE_MACRO(INT, Int);
828  DEFINE_LOCK_FREE_MACRO(LONG, Long);
829  DEFINE_LOCK_FREE_MACRO(LLONG, LongLong);
830  Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE",
832  TI.getPointerAlign(0),
833  InlineWidthBits));
834 #undef DEFINE_LOCK_FREE_MACRO
835  }
836 
837  if (LangOpts.NoInlineDefine)
838  Builder.defineMacro("__NO_INLINE__");
839 
840  if (unsigned PICLevel = LangOpts.PICLevel) {
841  Builder.defineMacro("__PIC__", Twine(PICLevel));
842  Builder.defineMacro("__pic__", Twine(PICLevel));
843  }
844  if (unsigned PIELevel = LangOpts.PIELevel) {
845  Builder.defineMacro("__PIE__", Twine(PIELevel));
846  Builder.defineMacro("__pie__", Twine(PIELevel));
847  }
848 
849  // Macros to control C99 numerics and <float.h>
850  Builder.defineMacro("__FLT_EVAL_METHOD__", Twine(TI.getFloatEvalMethod()));
851  Builder.defineMacro("__FLT_RADIX__", "2");
852  Builder.defineMacro("__DECIMAL_DIG__", "__LDBL_DECIMAL_DIG__");
853 
854  if (LangOpts.getStackProtector() == LangOptions::SSPOn)
855  Builder.defineMacro("__SSP__");
856  else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
857  Builder.defineMacro("__SSP_STRONG__", "2");
858  else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
859  Builder.defineMacro("__SSP_ALL__", "3");
860 
861  // Define a macro that exists only when using the static analyzer.
862  if (FEOpts.ProgramAction == frontend::RunAnalysis)
863  Builder.defineMacro("__clang_analyzer__");
864 
865  if (LangOpts.FastRelaxedMath)
866  Builder.defineMacro("__FAST_RELAXED_MATH__");
867 
868  if (FEOpts.ProgramAction == frontend::RewriteObjC ||
869  LangOpts.getGC() != LangOptions::NonGC) {
870  Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
871  Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
872  Builder.defineMacro("__autoreleasing", "");
873  Builder.defineMacro("__unsafe_unretained", "");
874  } else if (LangOpts.ObjC1) {
875  Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))");
876  Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))");
877  Builder.defineMacro("__autoreleasing",
878  "__attribute__((objc_ownership(autoreleasing)))");
879  Builder.defineMacro("__unsafe_unretained",
880  "__attribute__((objc_ownership(none)))");
881  }
882 
883  // On Darwin, there are __double_underscored variants of the type
884  // nullability qualifiers.
885  if (TI.getTriple().isOSDarwin()) {
886  Builder.defineMacro("__nonnull", "_Nonnull");
887  Builder.defineMacro("__null_unspecified", "_Null_unspecified");
888  Builder.defineMacro("__nullable", "_Nullable");
889  }
890 
891  // OpenMP definition
892  if (LangOpts.OpenMP) {
893  // OpenMP 2.2:
894  // In implementations that support a preprocessor, the _OPENMP
895  // macro name is defined to have the decimal value yyyymm where
896  // yyyy and mm are the year and the month designations of the
897  // version of the OpenMP API that the implementation support.
898  Builder.defineMacro("_OPENMP", "201307");
899  }
900 
901  // CUDA device path compilaton
902  if (LangOpts.CUDAIsDevice) {
903  // The CUDA_ARCH value is set for the GPU target specified in the NVPTX
904  // backend's target defines.
905  Builder.defineMacro("__CUDA_ARCH__");
906  }
907 
908  // Get other target #defines.
909  TI.getTargetDefines(LangOpts, Builder);
910 }
911 
912 /// InitializePreprocessor - Initialize the preprocessor getting it and the
913 /// environment ready to process a single file. This returns true on error.
914 ///
916  Preprocessor &PP, const PreprocessorOptions &InitOpts,
917  const PCHContainerReader &PCHContainerRdr,
918  const FrontendOptions &FEOpts) {
919  const LangOptions &LangOpts = PP.getLangOpts();
920  std::string PredefineBuffer;
921  PredefineBuffer.reserve(4080);
922  llvm::raw_string_ostream Predefines(PredefineBuffer);
923  MacroBuilder Builder(Predefines);
924 
925  // Emit line markers for various builtin sections of the file. We don't do
926  // this in asm preprocessor mode, because "# 4" is not a line marker directive
927  // in this mode.
928  if (!PP.getLangOpts().AsmPreprocessor)
929  Builder.append("# 1 \"<built-in>\" 3");
930 
931  // Install things like __POWERPC__, __GNUC__, etc into the macro table.
932  if (InitOpts.UsePredefines) {
933  if (LangOpts.CUDA && PP.getAuxTargetInfo())
934  InitializePredefinedMacros(*PP.getAuxTargetInfo(), LangOpts, FEOpts,
935  Builder);
936 
937  InitializePredefinedMacros(PP.getTargetInfo(), LangOpts, FEOpts, Builder);
938 
939  // Install definitions to make Objective-C++ ARC work well with various
940  // C++ Standard Library implementations.
941  if (LangOpts.ObjC1 && LangOpts.CPlusPlus &&
942  (LangOpts.ObjCAutoRefCount || LangOpts.ObjCWeak)) {
943  switch (InitOpts.ObjCXXARCStandardLibrary) {
944  case ARCXX_nolib:
945  case ARCXX_libcxx:
946  break;
947 
948  case ARCXX_libstdcxx:
949  AddObjCXXARCLibstdcxxDefines(LangOpts, Builder);
950  break;
951  }
952  }
953  }
954 
955  // Even with predefines off, some macros are still predefined.
956  // These should all be defined in the preprocessor according to the
957  // current language configuration.
959  FEOpts, Builder);
960 
961  // Add on the predefines from the driver. Wrap in a #line directive to report
962  // that they come from the command line.
963  if (!PP.getLangOpts().AsmPreprocessor)
964  Builder.append("# 1 \"<command line>\" 1");
965 
966  // Process #define's and #undef's in the order they are given.
967  for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
968  if (InitOpts.Macros[i].second) // isUndef
969  Builder.undefineMacro(InitOpts.Macros[i].first);
970  else
971  DefineBuiltinMacro(Builder, InitOpts.Macros[i].first,
972  PP.getDiagnostics());
973  }
974 
975  // If -imacros are specified, include them now. These are processed before
976  // any -include directives.
977  for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
978  AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i]);
979 
980  // Process -include-pch/-include-pth directives.
981  if (!InitOpts.ImplicitPCHInclude.empty())
982  AddImplicitIncludePCH(Builder, PP, PCHContainerRdr,
983  InitOpts.ImplicitPCHInclude);
984  if (!InitOpts.ImplicitPTHInclude.empty())
985  AddImplicitIncludePTH(Builder, PP, InitOpts.ImplicitPTHInclude);
986 
987  // Process -include directives.
988  for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {
989  const std::string &Path = InitOpts.Includes[i];
990  AddImplicitInclude(Builder, Path);
991  }
992 
993  // Exit the command line and go back to <built-in> (2 is LC_LEAVE).
994  if (!PP.getLangOpts().AsmPreprocessor)
995  Builder.append("# 1 \"<built-in>\" 2");
996 
997  // Instruct the preprocessor to skip the preamble.
999  InitOpts.PrecompiledPreambleBytes.second);
1000 
1001  // Copy PredefinedBuffer into the Preprocessor.
1002  PP.setPredefines(Predefines.str());
1003 }
std::vector< std::pair< std::string, bool > > Macros
Defines the clang::MacroBuilder utility class.
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
Defines the clang::FileManager interface and associated types.
static LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t', '\f', '\v', '\n', '\r'.
Definition: CharInfo.h:88
Defines the SourceManager interface.
static void DefineFmt(const Twine &Prefix, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
std::vector< std::string > Includes
Optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
Definition: VersionTuple.h:72
static void AddImplicitIncludeMacros(MacroBuilder &Builder, StringRef File)
StringRef getOriginalSourceFile()
Retrieve the name of the original source file name for the primary module file.
Definition: ASTReader.h:1480
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1117
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::string ImplicitPTHInclude
The implicit PTH input included at the start of the translation unit, or empty.
static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth, const TargetInfo &TI, MacroBuilder &Builder)
unsigned getLongDoubleWidth() const
getLongDoubleWidth/Align/Format - Return the size/align/format of 'long double'.
void setPredefines(const char *P)
Set the predefines for this Preprocessor.
Definition: Preprocessor.h:922
unsigned getFloatWidth() const
getFloatWidth/Align/Format - Return the size/align/format of 'float'.
static void AddImplicitIncludePCH(MacroBuilder &Builder, Preprocessor &PP, const PCHContainerReader &PCHContainerRdr, StringRef ImplicitIncludePCH)
Add an implicit #include using the original file used to generate a PCH file.
#define TOSTR(X)
static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts, MacroBuilder &Builder)
Add definitions required for a smooth interaction between Objective-C++ automated reference counting ...
unsigned getDoubleWidth() const
getDoubleWidth/Align/Format - Return the size/align/format of 'double'.
const char * getTypeConstantSuffix(IntType T) const
Return the constant suffix for the specified integer type enum.
void undefineMacro(const Twine &Name)
Append a #undef line for Name.
Definition: MacroBuilder.h:36
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:683
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
FileManager & getFileManager() const
Definition: Preprocessor.h:686
static bool isTypeSigned(IntType T)
Returns true if the type is signed; false otherwise.
virtual unsigned getFloatEvalMethod() const
Return the value for the C99 FLT_EVAL_METHOD macro.
const llvm::fltSemantics & getDoubleFormat() const
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:135
static void InitializePredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, MacroBuilder &Builder)
void append(const Twine &Str)
Directly append Str and a newline to the underlying buffer.
Definition: MacroBuilder.h:41
static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty, MacroBuilder &Builder)
const char * getOriginalSourceFile() const
getOriginalSourceFile - Return the full path to the original header file name that was used to genera...
Definition: PTHManager.h:120
static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix, const llvm::fltSemantics *Sem, StringRef Ext)
static void AddImplicitInclude(MacroBuilder &Builder, StringRef File)
AddImplicitInclude - Add an implicit #include of the specified file to the predefines buffer...
const TargetInfo & getTargetInfo() const
Definition: Preprocessor.h:684
static void DefineExactWidthIntTypeSize(TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
AnnotatingParser & P
static void DefineExactWidthIntType(TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
unsigned UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
Exposes information about the current target.
static void DefineLeastWidthIntType(unsigned TypeWidth, bool IsSigned, const TargetInfo &TI, MacroBuilder &Builder)
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:133
const char * getUserLabelPrefix() const
Returns the default value of the USER_LABEL_PREFIX macro, which is the prefix given to user symbols b...
static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth, StringRef ValSuffix, bool isSigned, MacroBuilder &Builder)
DefineTypeSize - Emit a macro to the predefines buffer that declares a macro named MacroName with the...
const llvm::fltSemantics & getFloatFormat() const
Defines version macros and version-related utility functions for Clang.
Defines the clang::Preprocessor interface.
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:85
The result type of a method or function.
static const char * getTypeName(IntType T)
Return the user string for the specified integer type enum.
static const char * getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign, unsigned InlineWidth)
Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with the specified properties...
static bool MacroBodyEndsInBackslash(StringRef MacroBody)
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:80
uint64_t getPointerAlign(unsigned AddrSpace) const
static void DefineFastIntType(unsigned TypeWidth, bool IsSigned, const TargetInfo &TI, MacroBuilder &Builder)
static void InitializeStandardPredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, MacroBuilder &Builder)
static void DefineBuiltinMacro(MacroBuilder &Builder, StringRef Macro, DiagnosticsEngine &Diags)
static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts, MacroBuilder &Builder)
Initialize the predefined C++ language feature test macros defined in ISO/IEC JTC1/SC22/WG21 (C++) SD...
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
'objfw' is the Objective-C runtime included in ObjFW
Definition: ObjCRuntime.h:56
static void AddImplicitIncludePTH(MacroBuilder &Builder, Preprocessor &PP, StringRef ImplicitIncludePTH)
AddImplicitIncludePTH - Add an implicit #include using the original file used to generate a PTH cache...
const TargetInfo * getAuxTargetInfo() const
Definition: Preprocessor.h:685
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:90
unsigned getMajor() const
Retrieve the major version number.
Definition: VersionTuple.h:69
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:76
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:680
std::vector< std::string > MacroIncludes
IntType
===-— Target Data Type Query Methods ----------------------------—===//
const llvm::fltSemantics & getLongDoubleFormat() const
static const char * getTypeFormatModifier(IntType T)
Return the printf format modifier for the specified integer type enum.
frontend::ActionKind ProgramAction
The frontend action to perform.
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
virtual IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return the smallest integer type with at least the specified width.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
unsigned getMaxAtomicInlineWidth() const
Return the maximum width lock-free atomic operation which can be inlined given the supported features...
FrontendOptions - Options for controlling the behavior of the frontend.
#define DEFINE_LOCK_FREE_MACRO(TYPE, Type)
virtual void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const =0
===-— Other target property query methods --------------------——===//
Optional< unsigned > getSubminor() const
Retrieve the subminor version number, if provided.
Definition: VersionTuple.h:79
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target, in bits.
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
std::string getClangFullCPPVersion()
Retrieves a string representing the complete clang version suitable for use in the CPP VERSION macro...
Definition: Version.cpp:139
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Kind getKind() const
Definition: ObjCRuntime.h:75
BoundNodesTreeBuilder *const Builder
void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts)
InitializePreprocessor - Initialize the preprocessor getting it and the environment ready to process ...
Run one or more source code analyses.
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target...
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
Defines the clang::TargetInfo interface.
#define CLANG_VERSION_STRING
A string that describes the Clang version number, e.g., "1.0".
Definition: Version.h:30
unsigned getSuitableAlign() const
Return the alignment that is suitable for storing any object with a fundamental alignment requirement...
void defineMacro(const Twine &Name, const Twine &Value="1")
Append a #define line for macro of the form "\#define Name Value\n".
Definition: MacroBuilder.h:30
void setSkipMainFilePreamble(unsigned Bytes, bool StartOfLine)
Instruct the preprocessor to skip part of the main source file.
static T PickFP(const llvm::fltSemantics *Sem, T IEEESingleVal, T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal, T IEEEQuadVal)
PickFP - This is used to pick a value based on the FP semantics of the specified FP model...
IntType getPtrDiffType(unsigned AddrSpace) const
PTHManager * getPTHManager()
Definition: Preprocessor.h:698
static void DefineTypeWidth(StringRef MacroName, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:96