clang  15.0.0git
InitPreprocessor.cpp
Go to the documentation of this file.
1 //===--- InitPreprocessor.cpp - PP initialization code. ---------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the clang::InitializePreprocessor function.
10 //
11 //===----------------------------------------------------------------------===//
12 
16 #include "clang/Basic/SyncScope.h"
17 #include "clang/Basic/TargetInfo.h"
18 #include "clang/Basic/Version.h"
21 #include "clang/Frontend/Utils.h"
22 #include "clang/Lex/HeaderSearch.h"
23 #include "clang/Lex/Preprocessor.h"
26 #include "llvm/ADT/APFloat.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/DerivedTypes.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 /// Add an implicit \#include using the original file used to generate
80 /// a PCH file.
82  const PCHContainerReader &PCHContainerRdr,
83  StringRef ImplicitIncludePCH) {
85  std::string(ImplicitIncludePCH), PP.getFileManager(), PCHContainerRdr,
86  PP.getDiagnostics());
87  if (OriginalFile.empty())
88  return;
89 
90  AddImplicitInclude(Builder, OriginalFile);
91 }
92 
93 /// PickFP - This is used to pick a value based on the FP semantics of the
94 /// specified FP model.
95 template <typename T>
96 static T PickFP(const llvm::fltSemantics *Sem, T IEEEHalfVal, T IEEESingleVal,
97  T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal,
98  T IEEEQuadVal) {
99  if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEhalf())
100  return IEEEHalfVal;
101  if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEsingle())
102  return IEEESingleVal;
103  if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEdouble())
104  return IEEEDoubleVal;
105  if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::x87DoubleExtended())
106  return X87DoubleExtendedVal;
107  if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::PPCDoubleDouble())
108  return PPCDoubleDoubleVal;
109  assert(Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEquad());
110  return IEEEQuadVal;
111 }
112 
113 static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix,
114  const llvm::fltSemantics *Sem, StringRef Ext) {
115  const char *DenormMin, *Epsilon, *Max, *Min;
116  DenormMin = PickFP(Sem, "5.9604644775390625e-8", "1.40129846e-45",
117  "4.9406564584124654e-324", "3.64519953188247460253e-4951",
118  "4.94065645841246544176568792868221e-324",
119  "6.47517511943802511092443895822764655e-4966");
120  int Digits = PickFP(Sem, 3, 6, 15, 18, 31, 33);
121  int DecimalDigits = PickFP(Sem, 5, 9, 17, 21, 33, 36);
122  Epsilon = PickFP(Sem, "9.765625e-4", "1.19209290e-7",
123  "2.2204460492503131e-16", "1.08420217248550443401e-19",
124  "4.94065645841246544176568792868221e-324",
125  "1.92592994438723585305597794258492732e-34");
126  int MantissaDigits = PickFP(Sem, 11, 24, 53, 64, 106, 113);
127  int Min10Exp = PickFP(Sem, -4, -37, -307, -4931, -291, -4931);
128  int Max10Exp = PickFP(Sem, 4, 38, 308, 4932, 308, 4932);
129  int MinExp = PickFP(Sem, -13, -125, -1021, -16381, -968, -16381);
130  int MaxExp = PickFP(Sem, 16, 128, 1024, 16384, 1024, 16384);
131  Min = PickFP(Sem, "6.103515625e-5", "1.17549435e-38", "2.2250738585072014e-308",
132  "3.36210314311209350626e-4932",
133  "2.00416836000897277799610805135016e-292",
134  "3.36210314311209350626267781732175260e-4932");
135  Max = PickFP(Sem, "6.5504e+4", "3.40282347e+38", "1.7976931348623157e+308",
136  "1.18973149535723176502e+4932",
137  "1.79769313486231580793728971405301e+308",
138  "1.18973149535723176508575932662800702e+4932");
139 
140  SmallString<32> DefPrefix;
141  DefPrefix = "__";
142  DefPrefix += Prefix;
143  DefPrefix += "_";
144 
145  Builder.defineMacro(DefPrefix + "DENORM_MIN__", Twine(DenormMin)+Ext);
146  Builder.defineMacro(DefPrefix + "HAS_DENORM__");
147  Builder.defineMacro(DefPrefix + "DIG__", Twine(Digits));
148  Builder.defineMacro(DefPrefix + "DECIMAL_DIG__", Twine(DecimalDigits));
149  Builder.defineMacro(DefPrefix + "EPSILON__", Twine(Epsilon)+Ext);
150  Builder.defineMacro(DefPrefix + "HAS_INFINITY__");
151  Builder.defineMacro(DefPrefix + "HAS_QUIET_NAN__");
152  Builder.defineMacro(DefPrefix + "MANT_DIG__", Twine(MantissaDigits));
153 
154  Builder.defineMacro(DefPrefix + "MAX_10_EXP__", Twine(Max10Exp));
155  Builder.defineMacro(DefPrefix + "MAX_EXP__", Twine(MaxExp));
156  Builder.defineMacro(DefPrefix + "MAX__", Twine(Max)+Ext);
157 
158  Builder.defineMacro(DefPrefix + "MIN_10_EXP__","("+Twine(Min10Exp)+")");
159  Builder.defineMacro(DefPrefix + "MIN_EXP__", "("+Twine(MinExp)+")");
160  Builder.defineMacro(DefPrefix + "MIN__", Twine(Min)+Ext);
161 }
162 
163 
164 /// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro
165 /// named MacroName with the max value for a type with width 'TypeWidth' a
166 /// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL).
167 static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth,
168  StringRef ValSuffix, bool isSigned,
169  MacroBuilder &Builder) {
170  llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth)
171  : llvm::APInt::getMaxValue(TypeWidth);
172  Builder.defineMacro(MacroName, toString(MaxVal, 10, isSigned) + ValSuffix);
173 }
174 
175 /// DefineTypeSize - An overloaded helper that uses TargetInfo to determine
176 /// the width, suffix, and signedness of the given type
177 static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty,
178  const TargetInfo &TI, MacroBuilder &Builder) {
179  DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty),
180  TI.isTypeSigned(Ty), Builder);
181 }
182 
183 static void DefineFmt(const Twine &Prefix, TargetInfo::IntType Ty,
184  const TargetInfo &TI, MacroBuilder &Builder) {
185  bool IsSigned = TI.isTypeSigned(Ty);
186  StringRef FmtModifier = TI.getTypeFormatModifier(Ty);
187  for (const char *Fmt = IsSigned ? "di" : "ouxX"; *Fmt; ++Fmt) {
188  Builder.defineMacro(Prefix + "_FMT" + Twine(*Fmt) + "__",
189  Twine("\"") + FmtModifier + Twine(*Fmt) + "\"");
190  }
191 }
192 
193 static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty,
194  MacroBuilder &Builder) {
195  Builder.defineMacro(MacroName, TargetInfo::getTypeName(Ty));
196 }
197 
198 static void DefineTypeWidth(const Twine &MacroName, TargetInfo::IntType Ty,
199  const TargetInfo &TI, MacroBuilder &Builder) {
200  Builder.defineMacro(MacroName, Twine(TI.getTypeWidth(Ty)));
201 }
202 
203 static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth,
204  const TargetInfo &TI, MacroBuilder &Builder) {
205  Builder.defineMacro(MacroName,
206  Twine(BitWidth / TI.getCharWidth()));
207 }
208 
209 // This will generate a macro based on the prefix with `_MAX__` as the suffix
210 // for the max value representable for the type, and a macro with a `_WIDTH__`
211 // suffix for the width of the type.
212 static void DefineTypeSizeAndWidth(const Twine &Prefix, TargetInfo::IntType Ty,
213  const TargetInfo &TI,
214  MacroBuilder &Builder) {
215  DefineTypeSize(Prefix + "_MAX__", Ty, TI, Builder);
216  DefineTypeWidth(Prefix + "_WIDTH__", Ty, TI, Builder);
217 }
218 
220  const TargetInfo &TI,
221  MacroBuilder &Builder) {
222  int TypeWidth = TI.getTypeWidth(Ty);
223  bool IsSigned = TI.isTypeSigned(Ty);
224 
225  // Use the target specified int64 type, when appropriate, so that [u]int64_t
226  // ends up being defined in terms of the correct type.
227  if (TypeWidth == 64)
228  Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
229 
230  // Use the target specified int16 type when appropriate. Some MCU targets
231  // (such as AVR) have definition of [u]int16_t to [un]signed int.
232  if (TypeWidth == 16)
233  Ty = IsSigned ? TI.getInt16Type() : TI.getUInt16Type();
234 
235  const char *Prefix = IsSigned ? "__INT" : "__UINT";
236 
237  DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
238  DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
239 
240  StringRef ConstSuffix(TI.getTypeConstantSuffix(Ty));
241  Builder.defineMacro(Prefix + Twine(TypeWidth) + "_C_SUFFIX__", ConstSuffix);
242 }
243 
245  const TargetInfo &TI,
246  MacroBuilder &Builder) {
247  int TypeWidth = TI.getTypeWidth(Ty);
248  bool IsSigned = TI.isTypeSigned(Ty);
249 
250  // Use the target specified int64 type, when appropriate, so that [u]int64_t
251  // ends up being defined in terms of the correct type.
252  if (TypeWidth == 64)
253  Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
254 
255  // We don't need to define a _WIDTH macro for the exact-width types because
256  // we already know the width.
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  // We only want the *_WIDTH macro for the signed types to avoid too many
271  // predefined macros (the unsigned width and the signed width are identical.)
272  if (IsSigned)
273  DefineTypeSizeAndWidth(Prefix + Twine(TypeWidth), Ty, TI, Builder);
274  else
275  DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
276  DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
277 }
278 
279 static void DefineFastIntType(unsigned TypeWidth, bool IsSigned,
280  const TargetInfo &TI, MacroBuilder &Builder) {
281  // stdint.h currently defines the fast int types as equivalent to the least
282  // types.
283  TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
284  if (Ty == TargetInfo::NoInt)
285  return;
286 
287  const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST";
288  DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
289  // We only want the *_WIDTH macro for the signed types to avoid too many
290  // predefined macros (the unsigned width and the signed width are identical.)
291  if (IsSigned)
292  DefineTypeSizeAndWidth(Prefix + Twine(TypeWidth), Ty, TI, Builder);
293  else
294  DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
295  DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
296 }
297 
298 
299 /// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with
300 /// the specified properties.
301 static const char *getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign,
302  unsigned InlineWidth) {
303  // Fully-aligned, power-of-2 sizes no larger than the inline
304  // width will be inlined as lock-free operations.
305  if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 &&
306  TypeWidth <= InlineWidth)
307  return "2"; // "always lock free"
308  // We cannot be certain what operations the lib calls might be
309  // able to implement as lock-free on future processors.
310  return "1"; // "sometimes lock free"
311 }
312 
313 /// Add definitions required for a smooth interaction between
314 /// Objective-C++ automated reference counting and libstdc++ (4.2).
315 static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts,
316  MacroBuilder &Builder) {
317  Builder.defineMacro("_GLIBCXX_PREDEFINED_OBJC_ARC_IS_SCALAR");
318 
319  std::string Result;
320  {
321  // Provide specializations for the __is_scalar type trait so that
322  // lifetime-qualified objects are not considered "scalar" types, which
323  // libstdc++ uses as an indicator of the presence of trivial copy, assign,
324  // default-construct, and destruct semantics (none of which hold for
325  // lifetime-qualified objects in ARC).
326  llvm::raw_string_ostream Out(Result);
327 
328  Out << "namespace std {\n"
329  << "\n"
330  << "struct __true_type;\n"
331  << "struct __false_type;\n"
332  << "\n";
333 
334  Out << "template<typename _Tp> struct __is_scalar;\n"
335  << "\n";
336 
337  if (LangOpts.ObjCAutoRefCount) {
338  Out << "template<typename _Tp>\n"
339  << "struct __is_scalar<__attribute__((objc_ownership(strong))) _Tp> {\n"
340  << " enum { __value = 0 };\n"
341  << " typedef __false_type __type;\n"
342  << "};\n"
343  << "\n";
344  }
345 
346  if (LangOpts.ObjCWeak) {
347  Out << "template<typename _Tp>\n"
348  << "struct __is_scalar<__attribute__((objc_ownership(weak))) _Tp> {\n"
349  << " enum { __value = 0 };\n"
350  << " typedef __false_type __type;\n"
351  << "};\n"
352  << "\n";
353  }
354 
355  if (LangOpts.ObjCAutoRefCount) {
356  Out << "template<typename _Tp>\n"
357  << "struct __is_scalar<__attribute__((objc_ownership(autoreleasing)))"
358  << " _Tp> {\n"
359  << " enum { __value = 0 };\n"
360  << " typedef __false_type __type;\n"
361  << "};\n"
362  << "\n";
363  }
364 
365  Out << "}\n";
366  }
367  Builder.append(Result);
368 }
369 
371  const LangOptions &LangOpts,
372  const FrontendOptions &FEOpts,
373  MacroBuilder &Builder) {
374  if (LangOpts.HLSL) {
375  Builder.defineMacro("__hlsl_clang");
376  // HLSL Version
377  Builder.defineMacro("__HLSL_VERSION",
378  Twine((unsigned)LangOpts.getHLSLVersion()));
379 
380  // Shader target information
381  // "enums" for shader stages
382  Builder.defineMacro("__SHADER_STAGE_VERTEX",
383  Twine((uint32_t)ShaderStage::Vertex));
384  Builder.defineMacro("__SHADER_STAGE_PIXEL",
385  Twine((uint32_t)ShaderStage::Pixel));
386  Builder.defineMacro("__SHADER_STAGE_GEOMETRY",
387  Twine((uint32_t)ShaderStage::Geometry));
388  Builder.defineMacro("__SHADER_STAGE_HULL",
389  Twine((uint32_t)ShaderStage::Hull));
390  Builder.defineMacro("__SHADER_STAGE_DOMAIN",
391  Twine((uint32_t)ShaderStage::Domain));
392  Builder.defineMacro("__SHADER_STAGE_COMPUTE",
393  Twine((uint32_t)ShaderStage::Compute));
394  Builder.defineMacro("__SHADER_STAGE_AMPLIFICATION",
395  Twine((uint32_t)ShaderStage::Amplification));
396  Builder.defineMacro("__SHADER_STAGE_MESH",
397  Twine((uint32_t)ShaderStage::Mesh));
398  Builder.defineMacro("__SHADER_STAGE_LIBRARY",
399  Twine((uint32_t)ShaderStage::Library));
400  // The current shader stage itself
401  uint32_t StageInteger = (uint32_t)TI.getTriple().getEnvironment() -
402  (uint32_t)llvm::Triple::Pixel;
403 
404  Builder.defineMacro("__SHADER_TARGET_STAGE", Twine(StageInteger));
405  // Add target versions
406  if (TI.getTriple().getOS() == llvm::Triple::ShaderModel) {
407  VersionTuple Version = TI.getTriple().getOSVersion();
408  Builder.defineMacro("__SHADER_TARGET_MAJOR", Twine(Version.getMajor()));
409  unsigned Minor = Version.getMinor() ? *Version.getMinor() : 0;
410  Builder.defineMacro("__SHADER_TARGET_MINOR", Twine(Minor));
411  }
412  return;
413  }
414  // C++ [cpp.predefined]p1:
415  // The following macro names shall be defined by the implementation:
416 
417  // -- __STDC__
418  // [C++] Whether __STDC__ is predefined and if so, what its value is,
419  // are implementation-defined.
420  // (Removed in C++20.)
421  if (!LangOpts.MSVCCompat && !LangOpts.TraditionalCPP)
422  Builder.defineMacro("__STDC__");
423  // -- __STDC_HOSTED__
424  // The integer literal 1 if the implementation is a hosted
425  // implementation or the integer literal 0 if it is not.
426  if (LangOpts.Freestanding)
427  Builder.defineMacro("__STDC_HOSTED__", "0");
428  else
429  Builder.defineMacro("__STDC_HOSTED__");
430 
431  // -- __STDC_VERSION__
432  // [C++] Whether __STDC_VERSION__ is predefined and if so, what its
433  // value is, are implementation-defined.
434  // (Removed in C++20.)
435  if (!LangOpts.CPlusPlus) {
436  // FIXME: Use correct value for C23.
437  if (LangOpts.C2x)
438  Builder.defineMacro("__STDC_VERSION__", "202000L");
439  else if (LangOpts.C17)
440  Builder.defineMacro("__STDC_VERSION__", "201710L");
441  else if (LangOpts.C11)
442  Builder.defineMacro("__STDC_VERSION__", "201112L");
443  else if (LangOpts.C99)
444  Builder.defineMacro("__STDC_VERSION__", "199901L");
445  else if (!LangOpts.GNUMode && LangOpts.Digraphs)
446  Builder.defineMacro("__STDC_VERSION__", "199409L");
447  } else {
448  // -- __cplusplus
449  // FIXME: Use correct value for C++23.
450  if (LangOpts.CPlusPlus2b)
451  Builder.defineMacro("__cplusplus", "202101L");
452  // [C++20] The integer literal 202002L.
453  else if (LangOpts.CPlusPlus20)
454  Builder.defineMacro("__cplusplus", "202002L");
455  // [C++17] The integer literal 201703L.
456  else if (LangOpts.CPlusPlus17)
457  Builder.defineMacro("__cplusplus", "201703L");
458  // [C++14] The name __cplusplus is defined to the value 201402L when
459  // compiling a C++ translation unit.
460  else if (LangOpts.CPlusPlus14)
461  Builder.defineMacro("__cplusplus", "201402L");
462  // [C++11] The name __cplusplus is defined to the value 201103L when
463  // compiling a C++ translation unit.
464  else if (LangOpts.CPlusPlus11)
465  Builder.defineMacro("__cplusplus", "201103L");
466  // [C++03] The name __cplusplus is defined to the value 199711L when
467  // compiling a C++ translation unit.
468  else
469  Builder.defineMacro("__cplusplus", "199711L");
470 
471  // -- __STDCPP_DEFAULT_NEW_ALIGNMENT__
472  // [C++17] An integer literal of type std::size_t whose value is the
473  // alignment guaranteed by a call to operator new(std::size_t)
474  //
475  // We provide this in all language modes, since it seems generally useful.
476  Builder.defineMacro("__STDCPP_DEFAULT_NEW_ALIGNMENT__",
477  Twine(TI.getNewAlign() / TI.getCharWidth()) +
479 
480  // -- __STDCPP_­THREADS__
481  // Defined, and has the value integer literal 1, if and only if a
482  // program can have more than one thread of execution.
483  if (LangOpts.getThreadModel() == LangOptions::ThreadModelKind::POSIX)
484  Builder.defineMacro("__STDCPP_THREADS__", "1");
485  }
486 
487  // In C11 these are environment macros. In C++11 they are only defined
488  // as part of <cuchar>. To prevent breakage when mixing C and C++
489  // code, define these macros unconditionally. We can define them
490  // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit
491  // and 32-bit character literals.
492  Builder.defineMacro("__STDC_UTF_16__", "1");
493  Builder.defineMacro("__STDC_UTF_32__", "1");
494 
495  if (LangOpts.ObjC)
496  Builder.defineMacro("__OBJC__");
497 
498  // OpenCL v1.0/1.1 s6.9, v1.2/2.0 s6.10: Preprocessor Directives and Macros.
499  if (LangOpts.OpenCL) {
500  if (LangOpts.CPlusPlus) {
501  switch (LangOpts.OpenCLCPlusPlusVersion) {
502  case 100:
503  Builder.defineMacro("__OPENCL_CPP_VERSION__", "100");
504  break;
505  case 202100:
506  Builder.defineMacro("__OPENCL_CPP_VERSION__", "202100");
507  break;
508  default:
509  llvm_unreachable("Unsupported C++ version for OpenCL");
510  }
511  Builder.defineMacro("__CL_CPP_VERSION_1_0__", "100");
512  Builder.defineMacro("__CL_CPP_VERSION_2021__", "202100");
513  } else {
514  // OpenCL v1.0 and v1.1 do not have a predefined macro to indicate the
515  // language standard with which the program is compiled. __OPENCL_VERSION__
516  // is for the OpenCL version supported by the OpenCL device, which is not
517  // necessarily the language standard with which the program is compiled.
518  // A shared OpenCL header file requires a macro to indicate the language
519  // standard. As a workaround, __OPENCL_C_VERSION__ is defined for
520  // OpenCL v1.0 and v1.1.
521  switch (LangOpts.OpenCLVersion) {
522  case 100:
523  Builder.defineMacro("__OPENCL_C_VERSION__", "100");
524  break;
525  case 110:
526  Builder.defineMacro("__OPENCL_C_VERSION__", "110");
527  break;
528  case 120:
529  Builder.defineMacro("__OPENCL_C_VERSION__", "120");
530  break;
531  case 200:
532  Builder.defineMacro("__OPENCL_C_VERSION__", "200");
533  break;
534  case 300:
535  Builder.defineMacro("__OPENCL_C_VERSION__", "300");
536  break;
537  default:
538  llvm_unreachable("Unsupported OpenCL version");
539  }
540  }
541  Builder.defineMacro("CL_VERSION_1_0", "100");
542  Builder.defineMacro("CL_VERSION_1_1", "110");
543  Builder.defineMacro("CL_VERSION_1_2", "120");
544  Builder.defineMacro("CL_VERSION_2_0", "200");
545  Builder.defineMacro("CL_VERSION_3_0", "300");
546 
547  if (TI.isLittleEndian())
548  Builder.defineMacro("__ENDIAN_LITTLE__");
549 
550  if (LangOpts.FastRelaxedMath)
551  Builder.defineMacro("__FAST_RELAXED_MATH__");
552  }
553 
554  if (LangOpts.SYCLIsDevice || LangOpts.SYCLIsHost) {
555  // SYCL Version is set to a value when building SYCL applications
556  if (LangOpts.getSYCLVersion() == LangOptions::SYCL_2017)
557  Builder.defineMacro("CL_SYCL_LANGUAGE_VERSION", "121");
558  else if (LangOpts.getSYCLVersion() == LangOptions::SYCL_2020)
559  Builder.defineMacro("SYCL_LANGUAGE_VERSION", "202001");
560  }
561 
562  // Not "standard" per se, but available even with the -undef flag.
563  if (LangOpts.AsmPreprocessor)
564  Builder.defineMacro("__ASSEMBLER__");
565  if (LangOpts.CUDA) {
566  if (LangOpts.GPURelocatableDeviceCode)
567  Builder.defineMacro("__CLANG_RDC__");
568  if (!LangOpts.HIP)
569  Builder.defineMacro("__CUDA__");
570  }
571  if (LangOpts.HIP) {
572  Builder.defineMacro("__HIP__");
573  Builder.defineMacro("__HIPCC__");
574  Builder.defineMacro("__HIP_MEMORY_SCOPE_SINGLETHREAD", "1");
575  Builder.defineMacro("__HIP_MEMORY_SCOPE_WAVEFRONT", "2");
576  Builder.defineMacro("__HIP_MEMORY_SCOPE_WORKGROUP", "3");
577  Builder.defineMacro("__HIP_MEMORY_SCOPE_AGENT", "4");
578  Builder.defineMacro("__HIP_MEMORY_SCOPE_SYSTEM", "5");
579  if (LangOpts.CUDAIsDevice)
580  Builder.defineMacro("__HIP_DEVICE_COMPILE__");
581  if (LangOpts.GPUDefaultStream ==
583  Builder.defineMacro("HIP_API_PER_THREAD_DEFAULT_STREAM");
584  }
585 }
586 
587 /// Initialize the predefined C++ language feature test macros defined in
588 /// ISO/IEC JTC1/SC22/WG21 (C++) SD-6: "SG10 Feature Test Recommendations".
590  MacroBuilder &Builder) {
591  // C++98 features.
592  if (LangOpts.RTTI)
593  Builder.defineMacro("__cpp_rtti", "199711L");
594  if (LangOpts.CXXExceptions)
595  Builder.defineMacro("__cpp_exceptions", "199711L");
596 
597  // C++11 features.
598  if (LangOpts.CPlusPlus11) {
599  Builder.defineMacro("__cpp_unicode_characters", "200704L");
600  Builder.defineMacro("__cpp_raw_strings", "200710L");
601  Builder.defineMacro("__cpp_unicode_literals", "200710L");
602  Builder.defineMacro("__cpp_user_defined_literals", "200809L");
603  Builder.defineMacro("__cpp_lambdas", "200907L");
604  Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus2b ? "202110L"
605  : LangOpts.CPlusPlus20 ? "201907L"
606  : LangOpts.CPlusPlus17 ? "201603L"
607  : LangOpts.CPlusPlus14 ? "201304L"
608  : "200704");
609  Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L");
610  Builder.defineMacro("__cpp_range_based_for",
611  LangOpts.CPlusPlus17 ? "201603L" : "200907");
612  Builder.defineMacro("__cpp_static_assert",
613  LangOpts.CPlusPlus17 ? "201411L" : "200410");
614  Builder.defineMacro("__cpp_decltype", "200707L");
615  Builder.defineMacro("__cpp_attributes", "200809L");
616  Builder.defineMacro("__cpp_rvalue_references", "200610L");
617  Builder.defineMacro("__cpp_variadic_templates", "200704L");
618  Builder.defineMacro("__cpp_initializer_lists", "200806L");
619  Builder.defineMacro("__cpp_delegating_constructors", "200604L");
620  Builder.defineMacro("__cpp_nsdmi", "200809L");
621  Builder.defineMacro("__cpp_inheriting_constructors", "201511L");
622  Builder.defineMacro("__cpp_ref_qualifiers", "200710L");
623  Builder.defineMacro("__cpp_alias_templates", "200704L");
624  }
625  if (LangOpts.ThreadsafeStatics)
626  Builder.defineMacro("__cpp_threadsafe_static_init", "200806L");
627 
628  // C++14 features.
629  if (LangOpts.CPlusPlus14) {
630  Builder.defineMacro("__cpp_binary_literals", "201304L");
631  Builder.defineMacro("__cpp_digit_separators", "201309L");
632  Builder.defineMacro("__cpp_init_captures",
633  LangOpts.CPlusPlus20 ? "201803L" : "201304L");
634  Builder.defineMacro("__cpp_generic_lambdas",
635  LangOpts.CPlusPlus20 ? "201707L" : "201304L");
636  Builder.defineMacro("__cpp_decltype_auto", "201304L");
637  Builder.defineMacro("__cpp_return_type_deduction", "201304L");
638  Builder.defineMacro("__cpp_aggregate_nsdmi", "201304L");
639  Builder.defineMacro("__cpp_variable_templates", "201304L");
640  }
641  if (LangOpts.SizedDeallocation)
642  Builder.defineMacro("__cpp_sized_deallocation", "201309L");
643 
644  // C++17 features.
645  if (LangOpts.CPlusPlus17) {
646  Builder.defineMacro("__cpp_hex_float", "201603L");
647  Builder.defineMacro("__cpp_inline_variables", "201606L");
648  Builder.defineMacro("__cpp_noexcept_function_type", "201510L");
649  Builder.defineMacro("__cpp_capture_star_this", "201603L");
650  Builder.defineMacro("__cpp_if_constexpr", "201606L");
651  Builder.defineMacro("__cpp_deduction_guides", "201703L"); // (not latest)
652  Builder.defineMacro("__cpp_template_auto", "201606L"); // (old name)
653  Builder.defineMacro("__cpp_namespace_attributes", "201411L");
654  Builder.defineMacro("__cpp_enumerator_attributes", "201411L");
655  Builder.defineMacro("__cpp_nested_namespace_definitions", "201411L");
656  Builder.defineMacro("__cpp_variadic_using", "201611L");
657  Builder.defineMacro("__cpp_aggregate_bases", "201603L");
658  Builder.defineMacro("__cpp_structured_bindings", "201606L");
659  Builder.defineMacro("__cpp_nontype_template_args",
660  "201411L"); // (not latest)
661  Builder.defineMacro("__cpp_fold_expressions", "201603L");
662  Builder.defineMacro("__cpp_guaranteed_copy_elision", "201606L");
663  Builder.defineMacro("__cpp_nontype_template_parameter_auto", "201606L");
664  }
665  if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)
666  Builder.defineMacro("__cpp_aligned_new", "201606L");
667  if (LangOpts.RelaxedTemplateTemplateArgs)
668  Builder.defineMacro("__cpp_template_template_args", "201611L");
669 
670  // C++20 features.
671  if (LangOpts.CPlusPlus20) {
672  //Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");
673  Builder.defineMacro("__cpp_concepts", "201907L");
674  Builder.defineMacro("__cpp_conditional_explicit", "201806L");
675  //Builder.defineMacro("__cpp_consteval", "201811L");
676  Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");
677  Builder.defineMacro("__cpp_constinit", "201907L");
678  Builder.defineMacro("__cpp_impl_coroutine", "201902L");
679  Builder.defineMacro("__cpp_designated_initializers", "201707L");
680  Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");
681  //Builder.defineMacro("__cpp_modules", "201907L");
682  Builder.defineMacro("__cpp_using_enum", "201907L");
683  }
684  // C++2b features.
685  if (LangOpts.CPlusPlus2b) {
686  Builder.defineMacro("__cpp_implicit_move", "202011L");
687  Builder.defineMacro("__cpp_size_t_suffix", "202011L");
688  Builder.defineMacro("__cpp_if_consteval", "202106L");
689  Builder.defineMacro("__cpp_­multidimensional_­subscript", "202110L");
690  }
691  if (LangOpts.Char8)
692  Builder.defineMacro("__cpp_char8_t", "201811L");
693  Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
694 
695  // TS features.
696  if (LangOpts.Coroutines)
697  Builder.defineMacro("__cpp_coroutines", "201703L");
698 }
699 
700 /// InitializeOpenCLFeatureTestMacros - Define OpenCL macros based on target
701 /// settings and language version
703  const LangOptions &Opts,
704  MacroBuilder &Builder) {
705  const llvm::StringMap<bool> &OpenCLFeaturesMap = TI.getSupportedOpenCLOpts();
706  // FIXME: OpenCL options which affect language semantics/syntax
707  // should be moved into LangOptions.
708  auto defineOpenCLExtMacro = [&](llvm::StringRef Name, auto... OptArgs) {
709  // Check if extension is supported by target and is available in this
710  // OpenCL version
711  if (TI.hasFeatureEnabled(OpenCLFeaturesMap, Name) &&
713  Builder.defineMacro(Name);
714  };
715 #define OPENCL_GENERIC_EXTENSION(Ext, ...) \
716  defineOpenCLExtMacro(#Ext, __VA_ARGS__);
717 #include "clang/Basic/OpenCLExtensions.def"
718 
719  // Assume compiling for FULL profile
720  Builder.defineMacro("__opencl_c_int64");
721 }
722 
724  const LangOptions &LangOpts,
725  const FrontendOptions &FEOpts,
726  const PreprocessorOptions &PPOpts,
727  MacroBuilder &Builder) {
728  // Compiler version introspection macros.
729  Builder.defineMacro("__llvm__"); // LLVM Backend
730  Builder.defineMacro("__clang__"); // Clang Frontend
731 #define TOSTR2(X) #X
732 #define TOSTR(X) TOSTR2(X)
733  Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR));
734  Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR));
735  Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL));
736 #undef TOSTR
737 #undef TOSTR2
738  Builder.defineMacro("__clang_version__",
739  "\"" CLANG_VERSION_STRING " "
740  + getClangFullRepositoryVersion() + "\"");
741 
742  if (LangOpts.GNUCVersion != 0) {
743  // Major, minor, patch, are given two decimal places each, so 4.2.1 becomes
744  // 40201.
745  unsigned GNUCMajor = LangOpts.GNUCVersion / 100 / 100;
746  unsigned GNUCMinor = LangOpts.GNUCVersion / 100 % 100;
747  unsigned GNUCPatch = LangOpts.GNUCVersion % 100;
748  Builder.defineMacro("__GNUC__", Twine(GNUCMajor));
749  Builder.defineMacro("__GNUC_MINOR__", Twine(GNUCMinor));
750  Builder.defineMacro("__GNUC_PATCHLEVEL__", Twine(GNUCPatch));
751  Builder.defineMacro("__GXX_ABI_VERSION", "1002");
752 
753  if (LangOpts.CPlusPlus) {
754  Builder.defineMacro("__GNUG__", Twine(GNUCMajor));
755  Builder.defineMacro("__GXX_WEAK__");
756  }
757  }
758 
759  // Define macros for the C11 / C++11 memory orderings
760  Builder.defineMacro("__ATOMIC_RELAXED", "0");
761  Builder.defineMacro("__ATOMIC_CONSUME", "1");
762  Builder.defineMacro("__ATOMIC_ACQUIRE", "2");
763  Builder.defineMacro("__ATOMIC_RELEASE", "3");
764  Builder.defineMacro("__ATOMIC_ACQ_REL", "4");
765  Builder.defineMacro("__ATOMIC_SEQ_CST", "5");
766 
767  // Define macros for the OpenCL memory scope.
768  // The values should match AtomicScopeOpenCLModel::ID enum.
769  static_assert(
770  static_cast<unsigned>(AtomicScopeOpenCLModel::WorkGroup) == 1 &&
771  static_cast<unsigned>(AtomicScopeOpenCLModel::Device) == 2 &&
772  static_cast<unsigned>(AtomicScopeOpenCLModel::AllSVMDevices) == 3 &&
773  static_cast<unsigned>(AtomicScopeOpenCLModel::SubGroup) == 4,
774  "Invalid OpenCL memory scope enum definition");
775  Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_ITEM", "0");
776  Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_GROUP", "1");
777  Builder.defineMacro("__OPENCL_MEMORY_SCOPE_DEVICE", "2");
778  Builder.defineMacro("__OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES", "3");
779  Builder.defineMacro("__OPENCL_MEMORY_SCOPE_SUB_GROUP", "4");
780 
781  // Support for #pragma redefine_extname (Sun compatibility)
782  Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");
783 
784  // Previously this macro was set to a string aiming to achieve compatibility
785  // with GCC 4.2.1. Now, just return the full Clang version
786  Builder.defineMacro("__VERSION__", "\"" +
787  Twine(getClangFullCPPVersion()) + "\"");
788 
789  // Initialize language-specific preprocessor defines.
790 
791  // Standard conforming mode?
792  if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)
793  Builder.defineMacro("__STRICT_ANSI__");
794 
795  if (LangOpts.GNUCVersion && LangOpts.CPlusPlus11)
796  Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");
797 
798  if (LangOpts.ObjC) {
799  if (LangOpts.ObjCRuntime.isNonFragile()) {
800  Builder.defineMacro("__OBJC2__");
801 
802  if (LangOpts.ObjCExceptions)
803  Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS");
804  }
805 
806  if (LangOpts.getGC() != LangOptions::NonGC)
807  Builder.defineMacro("__OBJC_GC__");
808 
809  if (LangOpts.ObjCRuntime.isNeXTFamily())
810  Builder.defineMacro("__NEXT_RUNTIME__");
811 
812  if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::GNUstep) {
813  auto version = LangOpts.ObjCRuntime.getVersion();
814  std::string versionString = "1";
815  // Don't rely on the tuple argument, because we can be asked to target
816  // later ABIs than we actually support, so clamp these values to those
817  // currently supported
818  if (version >= VersionTuple(2, 0))
819  Builder.defineMacro("__OBJC_GNUSTEP_RUNTIME_ABI__", "20");
820  else
821  Builder.defineMacro("__OBJC_GNUSTEP_RUNTIME_ABI__",
822  "1" + Twine(std::min(8U, version.getMinor().getValueOr(0))));
823  }
824 
825  if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::ObjFW) {
826  VersionTuple tuple = LangOpts.ObjCRuntime.getVersion();
827 
828  unsigned minor = 0;
829  if (tuple.getMinor().hasValue())
830  minor = tuple.getMinor().getValue();
831 
832  unsigned subminor = 0;
833  if (tuple.getSubminor().hasValue())
834  subminor = tuple.getSubminor().getValue();
835 
836  Builder.defineMacro("__OBJFW_RUNTIME_ABI__",
837  Twine(tuple.getMajor() * 10000 + minor * 100 +
838  subminor));
839  }
840 
841  Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))");
842  Builder.defineMacro("IBOutletCollection(ClassName)",
843  "__attribute__((iboutletcollection(ClassName)))");
844  Builder.defineMacro("IBAction", "void)__attribute__((ibaction)");
845  Builder.defineMacro("IBInspectable", "");
846  Builder.defineMacro("IB_DESIGNABLE", "");
847  }
848 
849  // Define a macro that describes the Objective-C boolean type even for C
850  // and C++ since BOOL can be used from non Objective-C code.
851  Builder.defineMacro("__OBJC_BOOL_IS_BOOL",
852  Twine(TI.useSignedCharForObjCBool() ? "0" : "1"));
853 
854  if (LangOpts.CPlusPlus)
855  InitializeCPlusPlusFeatureTestMacros(LangOpts, Builder);
856 
857  // darwin_constant_cfstrings controls this. This is also dependent
858  // on other things like the runtime I believe. This is set even for C code.
859  if (!LangOpts.NoConstantCFStrings)
860  Builder.defineMacro("__CONSTANT_CFSTRINGS__");
861 
862  if (LangOpts.ObjC)
863  Builder.defineMacro("OBJC_NEW_PROPERTIES");
864 
865  if (LangOpts.PascalStrings)
866  Builder.defineMacro("__PASCAL_STRINGS__");
867 
868  if (LangOpts.Blocks) {
869  Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");
870  Builder.defineMacro("__BLOCKS__");
871  }
872 
873  if (!LangOpts.MSVCCompat && LangOpts.Exceptions)
874  Builder.defineMacro("__EXCEPTIONS");
875  if (LangOpts.GNUCVersion && LangOpts.RTTI)
876  Builder.defineMacro("__GXX_RTTI");
877 
878  if (LangOpts.hasSjLjExceptions())
879  Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
880  else if (LangOpts.hasSEHExceptions())
881  Builder.defineMacro("__SEH__");
882  else if (LangOpts.hasDWARFExceptions() &&
883  (TI.getTriple().isThumb() || TI.getTriple().isARM()))
884  Builder.defineMacro("__ARM_DWARF_EH__");
885 
886  if (LangOpts.Deprecated)
887  Builder.defineMacro("__DEPRECATED");
888 
889  if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus)
890  Builder.defineMacro("__private_extern__", "extern");
891 
892  if (LangOpts.MicrosoftExt) {
893  if (LangOpts.WChar) {
894  // wchar_t supported as a keyword.
895  Builder.defineMacro("_WCHAR_T_DEFINED");
896  Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED");
897  }
898  }
899 
900  // Macros to help identify the narrow and wide character sets
901  // FIXME: clang currently ignores -fexec-charset=. If this changes,
902  // then this may need to be updated.
903  Builder.defineMacro("__clang_literal_encoding__", "\"UTF-8\"");
904  if (TI.getTypeWidth(TI.getWCharType()) >= 32) {
905  // FIXME: 32-bit wchar_t signals UTF-32. This may change
906  // if -fwide-exec-charset= is ever supported.
907  Builder.defineMacro("__clang_wide_literal_encoding__", "\"UTF-32\"");
908  } else {
909  // FIXME: Less-than 32-bit wchar_t generally means UTF-16
910  // (e.g., Windows, 32-bit IBM). This may need to be
911  // updated if -fwide-exec-charset= is ever supported.
912  Builder.defineMacro("__clang_wide_literal_encoding__", "\"UTF-16\"");
913  }
914 
915  if (LangOpts.Optimize)
916  Builder.defineMacro("__OPTIMIZE__");
917  if (LangOpts.OptimizeSize)
918  Builder.defineMacro("__OPTIMIZE_SIZE__");
919 
920  if (LangOpts.FastMath)
921  Builder.defineMacro("__FAST_MATH__");
922 
923  // Initialize target-specific preprocessor defines.
924 
925  // __BYTE_ORDER__ was added in GCC 4.6. It's analogous
926  // to the macro __BYTE_ORDER (no trailing underscores)
927  // from glibc's <endian.h> header.
928  // We don't support the PDP-11 as a target, but include
929  // the define so it can still be compared against.
930  Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234");
931  Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321");
932  Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412");
933  if (TI.isBigEndian()) {
934  Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__");
935  Builder.defineMacro("__BIG_ENDIAN__");
936  } else {
937  Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__");
938  Builder.defineMacro("__LITTLE_ENDIAN__");
939  }
940 
941  if (TI.getPointerWidth(0) == 64 && TI.getLongWidth() == 64
942  && TI.getIntWidth() == 32) {
943  Builder.defineMacro("_LP64");
944  Builder.defineMacro("__LP64__");
945  }
946 
947  if (TI.getPointerWidth(0) == 32 && TI.getLongWidth() == 32
948  && TI.getIntWidth() == 32) {
949  Builder.defineMacro("_ILP32");
950  Builder.defineMacro("__ILP32__");
951  }
952 
953  // Define type sizing macros based on the target properties.
954  assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");
955  Builder.defineMacro("__CHAR_BIT__", Twine(TI.getCharWidth()));
956 
957  Builder.defineMacro("__BOOL_WIDTH__", Twine(TI.getBoolWidth()));
958  Builder.defineMacro("__SHRT_WIDTH__", Twine(TI.getShortWidth()));
959  Builder.defineMacro("__INT_WIDTH__", Twine(TI.getIntWidth()));
960  Builder.defineMacro("__LONG_WIDTH__", Twine(TI.getLongWidth()));
961  Builder.defineMacro("__LLONG_WIDTH__", Twine(TI.getLongLongWidth()));
962 
963  size_t BitIntMaxWidth = TI.getMaxBitIntWidth();
964  assert(BitIntMaxWidth <= llvm::IntegerType::MAX_INT_BITS &&
965  "Target defined a max bit width larger than LLVM can support!");
966  assert(BitIntMaxWidth >= TI.getLongLongWidth() &&
967  "Target defined a max bit width smaller than the C standard allows!");
968  Builder.defineMacro("__BITINT_MAXWIDTH__", Twine(BitIntMaxWidth));
969 
970  DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder);
971  DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder);
972  DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder);
973  DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder);
974  DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder);
975  DefineTypeSizeAndWidth("__WCHAR", TI.getWCharType(), TI, Builder);
976  DefineTypeSizeAndWidth("__WINT", TI.getWIntType(), TI, Builder);
977  DefineTypeSizeAndWidth("__INTMAX", TI.getIntMaxType(), TI, Builder);
978  DefineTypeSizeAndWidth("__SIZE", TI.getSizeType(), TI, Builder);
979 
980  DefineTypeSizeAndWidth("__UINTMAX", TI.getUIntMaxType(), TI, Builder);
981  DefineTypeSizeAndWidth("__PTRDIFF", TI.getPtrDiffType(0), TI, Builder);
982  DefineTypeSizeAndWidth("__INTPTR", TI.getIntPtrType(), TI, Builder);
983  DefineTypeSizeAndWidth("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
984 
985  DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder);
986  DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder);
987  DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder);
988  DefineTypeSizeof("__SIZEOF_LONG__", TI.getLongWidth(), TI, Builder);
989  DefineTypeSizeof("__SIZEOF_LONG_DOUBLE__",TI.getLongDoubleWidth(),TI,Builder);
990  DefineTypeSizeof("__SIZEOF_LONG_LONG__", TI.getLongLongWidth(), TI, Builder);
991  DefineTypeSizeof("__SIZEOF_POINTER__", TI.getPointerWidth(0), TI, Builder);
992  DefineTypeSizeof("__SIZEOF_SHORT__", TI.getShortWidth(), TI, Builder);
993  DefineTypeSizeof("__SIZEOF_PTRDIFF_T__",
994  TI.getTypeWidth(TI.getPtrDiffType(0)), TI, Builder);
995  DefineTypeSizeof("__SIZEOF_SIZE_T__",
996  TI.getTypeWidth(TI.getSizeType()), TI, Builder);
997  DefineTypeSizeof("__SIZEOF_WCHAR_T__",
998  TI.getTypeWidth(TI.getWCharType()), TI, Builder);
999  DefineTypeSizeof("__SIZEOF_WINT_T__",
1000  TI.getTypeWidth(TI.getWIntType()), TI, Builder);
1001  if (TI.hasInt128Type())
1002  DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder);
1003 
1004  DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder);
1005  DefineFmt("__INTMAX", TI.getIntMaxType(), TI, Builder);
1006  Builder.defineMacro("__INTMAX_C_SUFFIX__",
1008  DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder);
1009  DefineFmt("__UINTMAX", TI.getUIntMaxType(), TI, Builder);
1010  Builder.defineMacro("__UINTMAX_C_SUFFIX__",
1012  DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Builder);
1013  DefineFmt("__PTRDIFF", TI.getPtrDiffType(0), TI, Builder);
1014  DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder);
1015  DefineFmt("__INTPTR", TI.getIntPtrType(), TI, Builder);
1016  DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder);
1017  DefineFmt("__SIZE", TI.getSizeType(), TI, Builder);
1018  DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder);
1019  DefineType("__WINT_TYPE__", TI.getWIntType(), Builder);
1020  DefineTypeSizeAndWidth("__SIG_ATOMIC", TI.getSigAtomicType(), TI, Builder);
1021  DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder);
1022  DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder);
1023 
1024  DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder);
1025  DefineFmt("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
1026 
1027  // The C standard requires the width of uintptr_t and intptr_t to be the same,
1028  // per 7.20.2.4p1. Same for intmax_t and uintmax_t, per 7.20.2.5p1.
1029  assert(TI.getTypeWidth(TI.getUIntPtrType()) ==
1030  TI.getTypeWidth(TI.getIntPtrType()) &&
1031  "uintptr_t and intptr_t have different widths?");
1032  assert(TI.getTypeWidth(TI.getUIntMaxType()) ==
1033  TI.getTypeWidth(TI.getIntMaxType()) &&
1034  "uintmax_t and intmax_t have different widths?");
1035 
1036  if (TI.hasFloat16Type())
1037  DefineFloatMacros(Builder, "FLT16", &TI.getHalfFormat(), "F16");
1038  DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
1039  DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
1040  DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
1041 
1042  // Define a __POINTER_WIDTH__ macro for stdint.h.
1043  Builder.defineMacro("__POINTER_WIDTH__",
1044  Twine((int)TI.getPointerWidth(0)));
1045 
1046  // Define __BIGGEST_ALIGNMENT__ to be compatible with gcc.
1047  Builder.defineMacro("__BIGGEST_ALIGNMENT__",
1048  Twine(TI.getSuitableAlign() / TI.getCharWidth()) );
1049 
1050  if (!LangOpts.CharIsSigned)
1051  Builder.defineMacro("__CHAR_UNSIGNED__");
1052 
1054  Builder.defineMacro("__WCHAR_UNSIGNED__");
1055 
1057  Builder.defineMacro("__WINT_UNSIGNED__");
1058 
1059  // Define exact-width integer types for stdint.h
1061 
1062  if (TI.getShortWidth() > TI.getCharWidth())
1064 
1065  if (TI.getIntWidth() > TI.getShortWidth())
1067 
1068  if (TI.getLongWidth() > TI.getIntWidth())
1070 
1071  if (TI.getLongLongWidth() > TI.getLongWidth())
1073 
1077 
1078  if (TI.getShortWidth() > TI.getCharWidth()) {
1082  }
1083 
1084  if (TI.getIntWidth() > TI.getShortWidth()) {
1088  }
1089 
1090  if (TI.getLongWidth() > TI.getIntWidth()) {
1094  }
1095 
1096  if (TI.getLongLongWidth() > TI.getLongWidth()) {
1100  }
1101 
1102  DefineLeastWidthIntType(8, true, TI, Builder);
1103  DefineLeastWidthIntType(8, false, TI, Builder);
1104  DefineLeastWidthIntType(16, true, TI, Builder);
1105  DefineLeastWidthIntType(16, false, TI, Builder);
1106  DefineLeastWidthIntType(32, true, TI, Builder);
1107  DefineLeastWidthIntType(32, false, TI, Builder);
1108  DefineLeastWidthIntType(64, true, TI, Builder);
1109  DefineLeastWidthIntType(64, false, TI, Builder);
1110 
1111  DefineFastIntType(8, true, TI, Builder);
1112  DefineFastIntType(8, false, TI, Builder);
1113  DefineFastIntType(16, true, TI, Builder);
1114  DefineFastIntType(16, false, TI, Builder);
1115  DefineFastIntType(32, true, TI, Builder);
1116  DefineFastIntType(32, false, TI, Builder);
1117  DefineFastIntType(64, true, TI, Builder);
1118  DefineFastIntType(64, false, TI, Builder);
1119 
1120  Builder.defineMacro("__USER_LABEL_PREFIX__", TI.getUserLabelPrefix());
1121 
1122  if (!LangOpts.MathErrno)
1123  Builder.defineMacro("__NO_MATH_ERRNO__");
1124 
1125  if (LangOpts.FastMath || LangOpts.FiniteMathOnly)
1126  Builder.defineMacro("__FINITE_MATH_ONLY__", "1");
1127  else
1128  Builder.defineMacro("__FINITE_MATH_ONLY__", "0");
1129 
1130  if (LangOpts.GNUCVersion) {
1131  if (LangOpts.GNUInline || LangOpts.CPlusPlus)
1132  Builder.defineMacro("__GNUC_GNU_INLINE__");
1133  else
1134  Builder.defineMacro("__GNUC_STDC_INLINE__");
1135 
1136  // The value written by __atomic_test_and_set.
1137  // FIXME: This is target-dependent.
1138  Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
1139  }
1140 
1141  auto addLockFreeMacros = [&](const llvm::Twine &Prefix) {
1142  // Used by libc++ and libstdc++ to implement ATOMIC_<foo>_LOCK_FREE.
1143  unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth();
1144 #define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \
1145  Builder.defineMacro(Prefix + #TYPE "_LOCK_FREE", \
1146  getLockFreeValue(TI.get##Type##Width(), \
1147  TI.get##Type##Align(), \
1148  InlineWidthBits));
1150  DEFINE_LOCK_FREE_MACRO(CHAR, Char);
1151  if (LangOpts.Char8)
1152  DEFINE_LOCK_FREE_MACRO(CHAR8_T, Char); // Treat char8_t like char.
1153  DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16);
1154  DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32);
1155  DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar);
1156  DEFINE_LOCK_FREE_MACRO(SHORT, Short);
1157  DEFINE_LOCK_FREE_MACRO(INT, Int);
1160  Builder.defineMacro(Prefix + "POINTER_LOCK_FREE",
1162  TI.getPointerAlign(0),
1163  InlineWidthBits));
1164 #undef DEFINE_LOCK_FREE_MACRO
1165  };
1166  addLockFreeMacros("__CLANG_ATOMIC_");
1167  if (LangOpts.GNUCVersion)
1168  addLockFreeMacros("__GCC_ATOMIC_");
1169 
1170  if (LangOpts.NoInlineDefine)
1171  Builder.defineMacro("__NO_INLINE__");
1172 
1173  if (unsigned PICLevel = LangOpts.PICLevel) {
1174  Builder.defineMacro("__PIC__", Twine(PICLevel));
1175  Builder.defineMacro("__pic__", Twine(PICLevel));
1176  if (LangOpts.PIE) {
1177  Builder.defineMacro("__PIE__", Twine(PICLevel));
1178  Builder.defineMacro("__pie__", Twine(PICLevel));
1179  }
1180  }
1181 
1182  // Macros to control C99 numerics and <float.h>
1183  Builder.defineMacro("__FLT_RADIX__", "2");
1184  Builder.defineMacro("__DECIMAL_DIG__", "__LDBL_DECIMAL_DIG__");
1185 
1186  if (LangOpts.getStackProtector() == LangOptions::SSPOn)
1187  Builder.defineMacro("__SSP__");
1188  else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
1189  Builder.defineMacro("__SSP_STRONG__", "2");
1190  else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
1191  Builder.defineMacro("__SSP_ALL__", "3");
1192 
1193  if (PPOpts.SetUpStaticAnalyzer)
1194  Builder.defineMacro("__clang_analyzer__");
1195 
1196  if (LangOpts.FastRelaxedMath)
1197  Builder.defineMacro("__FAST_RELAXED_MATH__");
1198 
1199  if (FEOpts.ProgramAction == frontend::RewriteObjC ||
1200  LangOpts.getGC() != LangOptions::NonGC) {
1201  Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
1202  Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
1203  Builder.defineMacro("__autoreleasing", "");
1204  Builder.defineMacro("__unsafe_unretained", "");
1205  } else if (LangOpts.ObjC) {
1206  Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))");
1207  Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))");
1208  Builder.defineMacro("__autoreleasing",
1209  "__attribute__((objc_ownership(autoreleasing)))");
1210  Builder.defineMacro("__unsafe_unretained",
1211  "__attribute__((objc_ownership(none)))");
1212  }
1213 
1214  // On Darwin, there are __double_underscored variants of the type
1215  // nullability qualifiers.
1216  if (TI.getTriple().isOSDarwin()) {
1217  Builder.defineMacro("__nonnull", "_Nonnull");
1218  Builder.defineMacro("__null_unspecified", "_Null_unspecified");
1219  Builder.defineMacro("__nullable", "_Nullable");
1220  }
1221 
1222  // Add a macro to differentiate between regular iOS/tvOS/watchOS targets and
1223  // the corresponding simulator targets.
1224  if (TI.getTriple().isOSDarwin() && TI.getTriple().isSimulatorEnvironment())
1225  Builder.defineMacro("__APPLE_EMBEDDED_SIMULATOR__", "1");
1226 
1227  // OpenMP definition
1228  // OpenMP 2.2:
1229  // In implementations that support a preprocessor, the _OPENMP
1230  // macro name is defined to have the decimal value yyyymm where
1231  // yyyy and mm are the year and the month designations of the
1232  // version of the OpenMP API that the implementation support.
1233  if (!LangOpts.OpenMPSimd) {
1234  switch (LangOpts.OpenMP) {
1235  case 0:
1236  break;
1237  case 31:
1238  Builder.defineMacro("_OPENMP", "201107");
1239  break;
1240  case 40:
1241  Builder.defineMacro("_OPENMP", "201307");
1242  break;
1243  case 45:
1244  Builder.defineMacro("_OPENMP", "201511");
1245  break;
1246  case 51:
1247  Builder.defineMacro("_OPENMP", "202011");
1248  break;
1249  case 52:
1250  Builder.defineMacro("_OPENMP", "202111");
1251  break;
1252  case 50:
1253  default:
1254  // Default version is OpenMP 5.0
1255  Builder.defineMacro("_OPENMP", "201811");
1256  break;
1257  }
1258  }
1259 
1260  // CUDA device path compilaton
1261  if (LangOpts.CUDAIsDevice && !LangOpts.HIP) {
1262  // The CUDA_ARCH value is set for the GPU target specified in the NVPTX
1263  // backend's target defines.
1264  Builder.defineMacro("__CUDA_ARCH__");
1265  }
1266 
1267  // We need to communicate this to our CUDA header wrapper, which in turn
1268  // informs the proper CUDA headers of this choice.
1269  if (LangOpts.CUDADeviceApproxTranscendentals || LangOpts.FastMath) {
1270  Builder.defineMacro("__CLANG_CUDA_APPROX_TRANSCENDENTALS__");
1271  }
1272 
1273  // Define a macro indicating that the source file is being compiled with a
1274  // SYCL device compiler which doesn't produce host binary.
1275  if (LangOpts.SYCLIsDevice) {
1276  Builder.defineMacro("__SYCL_DEVICE_ONLY__", "1");
1277  }
1278 
1279  // OpenCL definitions.
1280  if (LangOpts.OpenCL) {
1281  InitializeOpenCLFeatureTestMacros(TI, LangOpts, Builder);
1282 
1283  if (TI.getTriple().isSPIR() || TI.getTriple().isSPIRV())
1284  Builder.defineMacro("__IMAGE_SUPPORT__");
1285  }
1286 
1287  if (TI.hasInt128Type() && LangOpts.CPlusPlus && LangOpts.GNUMode) {
1288  // For each extended integer type, g++ defines a macro mapping the
1289  // index of the type (0 in this case) in some list of extended types
1290  // to the type.
1291  Builder.defineMacro("__GLIBCXX_TYPE_INT_N_0", "__int128");
1292  Builder.defineMacro("__GLIBCXX_BITSIZE_INT_N_0", "128");
1293  }
1294 
1295  // Get other target #defines.
1296  TI.getTargetDefines(LangOpts, Builder);
1297 }
1298 
1299 /// InitializePreprocessor - Initialize the preprocessor getting it and the
1300 /// environment ready to process a single file. This returns true on error.
1301 ///
1303  Preprocessor &PP, const PreprocessorOptions &InitOpts,
1304  const PCHContainerReader &PCHContainerRdr,
1305  const FrontendOptions &FEOpts) {
1306  const LangOptions &LangOpts = PP.getLangOpts();
1307  std::string PredefineBuffer;
1308  PredefineBuffer.reserve(4080);
1309  llvm::raw_string_ostream Predefines(PredefineBuffer);
1310  MacroBuilder Builder(Predefines);
1311 
1312  // Emit line markers for various builtin sections of the file. We don't do
1313  // this in asm preprocessor mode, because "# 4" is not a line marker directive
1314  // in this mode.
1315  if (!PP.getLangOpts().AsmPreprocessor)
1316  Builder.append("# 1 \"<built-in>\" 3");
1317 
1318  // Install things like __POWERPC__, __GNUC__, etc into the macro table.
1319  if (InitOpts.UsePredefines) {
1320  // FIXME: This will create multiple definitions for most of the predefined
1321  // macros. This is not the right way to handle this.
1322  if ((LangOpts.CUDA || LangOpts.OpenMPIsDevice || LangOpts.SYCLIsDevice) &&
1323  PP.getAuxTargetInfo())
1324  InitializePredefinedMacros(*PP.getAuxTargetInfo(), LangOpts, FEOpts,
1325  PP.getPreprocessorOpts(), Builder);
1326 
1327  InitializePredefinedMacros(PP.getTargetInfo(), LangOpts, FEOpts,
1328  PP.getPreprocessorOpts(), Builder);
1329 
1330  // Install definitions to make Objective-C++ ARC work well with various
1331  // C++ Standard Library implementations.
1332  if (LangOpts.ObjC && LangOpts.CPlusPlus &&
1333  (LangOpts.ObjCAutoRefCount || LangOpts.ObjCWeak)) {
1334  switch (InitOpts.ObjCXXARCStandardLibrary) {
1335  case ARCXX_nolib:
1336  case ARCXX_libcxx:
1337  break;
1338 
1339  case ARCXX_libstdcxx:
1340  AddObjCXXARCLibstdcxxDefines(LangOpts, Builder);
1341  break;
1342  }
1343  }
1344  }
1345 
1346  // Even with predefines off, some macros are still predefined.
1347  // These should all be defined in the preprocessor according to the
1348  // current language configuration.
1350  FEOpts, Builder);
1351 
1352  // Add on the predefines from the driver. Wrap in a #line directive to report
1353  // that they come from the command line.
1354  if (!PP.getLangOpts().AsmPreprocessor)
1355  Builder.append("# 1 \"<command line>\" 1");
1356 
1357  // Process #define's and #undef's in the order they are given.
1358  for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
1359  if (InitOpts.Macros[i].second) // isUndef
1360  Builder.undefineMacro(InitOpts.Macros[i].first);
1361  else
1362  DefineBuiltinMacro(Builder, InitOpts.Macros[i].first,
1363  PP.getDiagnostics());
1364  }
1365 
1366  // Exit the command line and go back to <built-in> (2 is LC_LEAVE).
1367  if (!PP.getLangOpts().AsmPreprocessor)
1368  Builder.append("# 1 \"<built-in>\" 2");
1369 
1370  // If -imacros are specified, include them now. These are processed before
1371  // any -include directives.
1372  for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
1373  AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i]);
1374 
1375  // Process -include-pch/-include-pth directives.
1376  if (!InitOpts.ImplicitPCHInclude.empty())
1377  AddImplicitIncludePCH(Builder, PP, PCHContainerRdr,
1378  InitOpts.ImplicitPCHInclude);
1379 
1380  // Process -include directives.
1381  for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {
1382  const std::string &Path = InitOpts.Includes[i];
1383  AddImplicitInclude(Builder, Path);
1384  }
1385 
1386  // Instruct the preprocessor to skip the preamble.
1388  InitOpts.PrecompiledPreambleBytes.second);
1389 
1390  // Copy PredefinedBuffer into the Preprocessor.
1391  PP.setPredefines(std::move(PredefineBuffer));
1392 }
clang::TypeSpecifierWidth::LongLong
@ LongLong
clang::ShaderStage::Pixel
@ Pixel
clang::Preprocessor::setSkipMainFilePreamble
void setSkipMainFilePreamble(unsigned Bytes, bool StartOfLine)
Instruct the preprocessor to skip part of the main source file.
Definition: Preprocessor.h:1798
clang::LangOptions::hasSEHExceptions
bool hasSEHExceptions() const
Definition: LangOptions.h:573
clang::TargetInfo::getLongDoubleFormat
const llvm::fltSemantics & getLongDoubleFormat() const
Definition: TargetInfo.h:694
clang::AtomicScopeOpenCLModel::WorkGroup
@ WorkGroup
Definition: SyncScope.h:115
DefineBuiltinMacro
static void DefineBuiltinMacro(MacroBuilder &Builder, StringRef Macro, DiagnosticsEngine &Diags)
Definition: InitPreprocessor.cpp:40
clang::PreprocessorOptions::SetUpStaticAnalyzer
bool SetUpStaticAnalyzer
Set up preprocessor for RunAnalysis action.
Definition: PreprocessorOptions.h:212
clang::TransferrableTargetInfo::UnsignedChar
@ UnsignedChar
Definition: TargetInfo.h:119
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::DeclaratorContext::File
@ File
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::PreprocessorOptions
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Definition: PreprocessorOptions.h:64
clang::TransferrableTargetInfo::SignedChar
@ SignedChar
Definition: TargetInfo.h:118
clang::TargetInfo::getTypeConstantSuffix
const char * getTypeConstantSuffix(IntType T) const
Return the constant suffix for the specified integer type enum.
Definition: TargetInfo.cpp:196
clang::FrontendOptions::ProgramAction
frontend::ActionKind ProgramAction
The frontend action to perform.
Definition: FrontendOptions.h:445
clang::TargetInfo::getDoubleFormat
const llvm::fltSemantics & getDoubleFormat() const
Definition: TargetInfo.h:688
clang::TargetInfo::getLongWidth
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
Definition: TargetInfo.h:459
clang::TargetInfo::getSuitableAlign
unsigned getSuitableAlign() const
Return the alignment that is the largest alignment ever used for any scalar/SIMD data type on the tar...
Definition: TargetInfo.h:634
clang::LangOptions::SSPStrong
@ SSPStrong
Definition: LangOptions.h:84
clang::TargetInfo::getNewAlign
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' is g...
Definition: TargetInfo.h:651
clang::ObjCRuntime::getKind
Kind getKind() const
Definition: ObjCRuntime.h:77
clang::ShaderStage::Library
@ Library
DefineType
static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:193
clang::TargetInfo::getUserLabelPrefix
const char * getUserLabelPrefix() const
Returns the default value of the USER_LABEL_PREFIX macro, which is the prefix given to user symbols b...
Definition: TargetInfo.h:806
TargetInfo.h
clang::TargetInfo::isTypeSigned
static bool isTypeSigned(IntType T)
Returns true if the type is signed; false otherwise.
Definition: TargetInfo.cpp:337
DefineExactWidthIntType
static void DefineExactWidthIntType(TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:219
clang::LangOptions::SSPReq
@ SSPReq
Definition: LangOptions.h:84
DefineTypeWidth
static void DefineTypeWidth(const Twine &MacroName, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:198
clang::TransferrableTargetInfo::UnsignedShort
@ UnsignedShort
Definition: TargetInfo.h:121
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
clang::ARCXX_nolib
@ ARCXX_nolib
Definition: PreprocessorOptions.h:35
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:186
clang::TargetInfo::hasFloat16Type
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
Definition: TargetInfo.h:613
TOSTR
#define TOSTR(X)
clang::TargetInfo::getBoolWidth
unsigned getBoolWidth() const
Return the size of '_Bool' and C++ 'bool' for this target, in bits.
Definition: TargetInfo.h:436
clang::TargetInfo::getCharWidth
unsigned getCharWidth() const
Definition: TargetInfo.h:441
clang::ASTReader::getOriginalSourceFile
StringRef getOriginalSourceFile()
Retrieve the name of the original source file name for the primary module file.
Definition: ASTReader.h:1713
clang::ShaderStage::Domain
@ Domain
clang::TargetInfo::isBigEndian
bool isBigEndian() const
Definition: TargetInfo.h:1484
SourceManager.h
clang::TargetInfo::getLongLongWidth
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
Definition: TargetInfo.h:464
PickFP
static T PickFP(const llvm::fltSemantics *Sem, T IEEEHalfVal, 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.
Definition: InitPreprocessor.cpp:96
clang::LangOptions::hasDWARFExceptions
bool hasDWARFExceptions() const
Definition: LangOptions.h:577
clang::TransferrableTargetInfo::UnsignedLongLong
@ UnsignedLongLong
Definition: TargetInfo.h:127
clang::TargetInfo::hasInt128Type
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:581
End
SourceLocation End
Definition: USRLocFinder.cpp:167
clang::frontend::RewriteObjC
@ RewriteObjC
ObjC->C Rewriter.
Definition: FrontendOptions.h:127
clang::Preprocessor::setPredefines
void setPredefines(std::string P)
Set the predefines for this Preprocessor.
Definition: Preprocessor.h:1286
clang::PreprocessorOptions::Includes
std::vector< std::string > Includes
Definition: PreprocessorOptions.h:67
clang::PCHContainerReader
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
Definition: PCHContainerOperations.h:55
clang::ShaderStage::Vertex
@ Vertex
clang::TargetInfo::getPtrDiffType
IntType getPtrDiffType(unsigned AddrSpace) const
Definition: TargetInfo.h:338
clang::TargetInfo::getUInt64Type
IntType getUInt64Type() const
Definition: TargetInfo.h:353
clang::AtomicScopeOpenCLModel::SubGroup
@ SubGroup
Definition: SyncScope.h:118
clang::Preprocessor::getLangOpts
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:994
Preprocessor.h
AddImplicitIncludePCH
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.
Definition: InitPreprocessor.cpp:81
clang::ObjCRuntime::getVersion
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:78
clang::TargetInfo::getMaxAtomicInlineWidth
unsigned getMaxAtomicInlineWidth() const
Return the maximum width lock-free atomic operation which can be inlined given the supported features...
Definition: TargetInfo.h:745
clang::TargetInfo::getLongDoubleWidth
unsigned getLongDoubleWidth() const
getLongDoubleWidth/Align/Format - Return the size/align/format of 'long double'.
Definition: TargetInfo.h:692
U
clang::TargetInfo::getSupportedOpenCLOpts
llvm::StringMap< bool > & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1576
clang::TargetInfo::useSignedCharForObjCBool
bool useSignedCharForObjCBool() const
Check if the Objective-C built-in boolean type should be signed char.
Definition: TargetInfo.h:818
AddImplicitInclude
static void AddImplicitInclude(MacroBuilder &Builder, StringRef File)
AddImplicitInclude - Add an implicit #include of the specified file to the predefines buffer.
Definition: InitPreprocessor.cpp:69
clang::TargetInfo::getIntPtrType
IntType getIntPtrType() const
Definition: TargetInfo.h:344
min
__DEVICE__ int min(int __a, int __b)
Definition: __clang_cuda_math.h:197
InitializeOpenCLFeatureTestMacros
void InitializeOpenCLFeatureTestMacros(const TargetInfo &TI, const LangOptions &Opts, MacroBuilder &Builder)
InitializeOpenCLFeatureTestMacros - Define OpenCL macros based on target settings and language versio...
Definition: InitPreprocessor.cpp:702
clang::TargetInfo::getFloatWidth
unsigned getFloatWidth() const
getFloatWidth/Align/Format - Return the size/align/format of 'float'.
Definition: TargetInfo.h:676
clang::LangOptions::ObjCRuntime
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:390
clang::TargetInfo::isLittleEndian
bool isLittleEndian() const
Definition: TargetInfo.h:1485
FrontendOptions.h
clang::TargetInfo::getChar32Type
IntType getChar32Type() const
Definition: TargetInfo.h:351
clang::threadSafety::sx::toString
std::string toString(const til::SExpr *E)
Definition: ThreadSafetyCommon.h:90
Version.h
clang::LangOptions::ThreadModelKind::POSIX
@ POSIX
POSIX Threads.
clang::TargetInfo::getPointerAlign
uint64_t getPointerAlign(unsigned AddrSpace) const
Definition: TargetInfo.h:422
clang::FrontendOptions
FrontendOptions - Options for controlling the behavior of the frontend.
Definition: FrontendOptions.h:268
Utils.h
MacroBuilder.h
clang::InitializePreprocessor
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 ...
Definition: InitPreprocessor.cpp:1302
InitializePredefinedMacros
static void InitializePredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, const PreprocessorOptions &PPOpts, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:723
clang::Preprocessor::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: Preprocessor.h:995
llvm::SmallString< 32 >
DEFINE_LOCK_FREE_MACRO
#define DEFINE_LOCK_FREE_MACRO(TYPE, Type)
clang::TargetInfo::getFloatFormat
const llvm::fltSemantics & getFloatFormat() const
Definition: TargetInfo.h:678
clang::getClangFullRepositoryVersion
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:60
clang::PreprocessorOptions::UsePredefines
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
Definition: PreprocessorOptions.h:72
clang::LangOptions::hasSjLjExceptions
bool hasSjLjExceptions() const
Definition: LangOptions.h:569
clang::LangOptions::SYCL_2017
@ SYCL_2017
Definition: LangOptions.h:156
DefineExactWidthIntTypeSize
static void DefineExactWidthIntTypeSize(TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:244
clang::TargetInfo::getHalfFormat
const llvm::fltSemantics & getHalfFormat() const
Definition: TargetInfo.h:673
clang::TargetInfo::getLeastIntTypeByWidth
virtual IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return the smallest integer type with at least the specified width.
Definition: TargetInfo.cpp:270
clang::ARCXX_libcxx
@ ARCXX_libcxx
libc++
Definition: PreprocessorOptions.h:38
MacroBodyEndsInBackslash
static bool MacroBodyEndsInBackslash(StringRef MacroBody)
Definition: InitPreprocessor.cpp:31
clang::TargetInfo::getDoubleWidth
unsigned getDoubleWidth() const
getDoubleWidth/Align/Format - Return the size/align/format of 'double'.
Definition: TargetInfo.h:686
clang::TargetInfo::getMaxBitIntWidth
virtual size_t getMaxBitIntWidth() const
Definition: TargetInfo.h:597
getLockFreeValue
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.
Definition: InitPreprocessor.cpp:301
clang::ObjCRuntime::isNeXTFamily
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:135
DefineTypeSize
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...
Definition: InitPreprocessor.cpp:167
clang::ObjCRuntime::ObjFW
@ ObjFW
'objfw' is the Objective-C runtime included in ObjFW
Definition: ObjCRuntime.h:59
clang::ShaderStage::Geometry
@ Geometry
clang::TargetInfo::getTriple
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1160
clang::TargetInfo::getSizeType
IntType getSizeType() const
Definition: TargetInfo.h:319
GCCTypeClass::Bool
@ Bool
clang::isWhitespace
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
Definition: CharInfo.h:93
clang::TargetInfo::getUInt16Type
IntType getUInt16Type() const
Definition: TargetInfo.h:357
clang::TargetInfo::getTargetDefines
virtual void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const =0
===-— Other target property query methods -----------------------—===//
clang::TargetInfo::getInt16Type
IntType getInt16Type() const
Definition: TargetInfo.h:356
clang::Preprocessor::getAuxTargetInfo
const TargetInfo * getAuxTargetInfo() const
Definition: Preprocessor.h:996
clang::TargetInfo::getUIntPtrType
IntType getUIntPtrType() const
Definition: TargetInfo.h:345
DefineLeastWidthIntType
static void DefineLeastWidthIntType(unsigned TypeWidth, bool IsSigned, const TargetInfo &TI, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:261
clang::TargetInfo::getTypeName
static const char * getTypeName(IntType T)
Return the user string for the specified integer type enum.
Definition: TargetInfo.cpp:178
clang::ShaderStage::Amplification
@ Amplification
InitializeCPlusPlusFeatureTestMacros
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...
Definition: InitPreprocessor.cpp:589
clang::ObjCRuntime::GNUstep
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:56
clang::LangOptions::NonGC
@ NonGC
Definition: LangOptions.h:83
clang::TransferrableTargetInfo::NoInt
@ NoInt
Definition: TargetInfo.h:117
clang::TargetInfo::getWIntType
IntType getWIntType() const
Definition: TargetInfo.h:349
clang::LangOptions::SYCL_2020
@ SYCL_2020
Definition: LangOptions.h:157
AddImplicitIncludeMacros
static void AddImplicitIncludeMacros(MacroBuilder &Builder, StringRef File)
Definition: InitPreprocessor.cpp:73
HeaderSearch.h
clang::LangOptions::GPUDefaultStream
GPUDefaultStreamKind GPUDefaultStream
The default stream kind used for HIP kernel launching.
Definition: LangOptions.h:450
clang::PreprocessorOptions::PrecompiledPreambleBytes
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
Definition: PreprocessorOptions.h:125
AddObjCXXARCLibstdcxxDefines
static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts, MacroBuilder &Builder)
Add definitions required for a smooth interaction between Objective-C++ automated reference counting ...
Definition: InitPreprocessor.cpp:315
clang::LangOptions::SSPOn
@ SSPOn
Definition: LangOptions.h:84
clang::TargetInfo::getUIntMaxType
IntType getUIntMaxType() const
Definition: TargetInfo.h:335
clang::TargetInfo::getIntMaxType
IntType getIntMaxType() const
Definition: TargetInfo.h:334
clang::Preprocessor::getFileManager
FileManager & getFileManager() const
Definition: Preprocessor.h:997
DefineFloatMacros
static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix, const llvm::fltSemantics *Sem, StringRef Ext)
Definition: InitPreprocessor.cpp:113
clang::PreprocessorOptions::ObjCXXARCStandardLibrary
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
Definition: PreprocessorOptions.h:179
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:78
clang::Preprocessor::getPreprocessorOpts
PreprocessorOptions & getPreprocessorOpts() const
Retrieve the preprocessor options used to initialize this preprocessor.
Definition: Preprocessor.h:989
clang::TransferrableTargetInfo::IntType
IntType
===-— Target Data Type Query Methods ----------------------------—===//
Definition: TargetInfo.h:116
clang::TargetInfo::getChar16Type
IntType getChar16Type() const
Definition: TargetInfo.h:350
DefineFastIntType
static void DefineFastIntType(unsigned TypeWidth, bool IsSigned, const TargetInfo &TI, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:279
clang::TargetInfo::getShortWidth
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
Definition: TargetInfo.h:446
clang::AtomicScopeOpenCLModel::AllSVMDevices
@ AllSVMDevices
Definition: SyncScope.h:117
clang::ARCXX_libstdcxx
@ ARCXX_libstdcxx
libstdc++
Definition: PreprocessorOptions.h:41
clang::TargetInfo::getTypeWidth
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
Definition: TargetInfo.cpp:239
clang::LangOptions::GPUDefaultStreamKind::PerThread
@ PerThread
Per-thread default stream.
clang
Definition: CalledOnceCheck.h:17
clang::TargetInfo::getTypeFormatModifier
static const char * getTypeFormatModifier(IntType T)
Return the printf format modifier for the specified integer type enum.
Definition: TargetInfo.cpp:221
clang::TargetInfo::getPointerWidth
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:419
FrontendDiagnostic.h
ASTReader.h
clang::TargetInfo::hasFeatureEnabled
virtual bool hasFeatureEnabled(const llvm::StringMap< bool > &Features, StringRef Name) const
Check if target has a given feature enabled.
Definition: TargetInfo.h:1283
clang::Preprocessor::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:991
clang::TransferrableTargetInfo::SignedInt
@ SignedInt
Definition: TargetInfo.h:122
clang::TransferrableTargetInfo::UnsignedLong
@ UnsignedLong
Definition: TargetInfo.h:125
clang::TransferrableTargetInfo::SignedLongLong
@ SignedLongLong
Definition: TargetInfo.h:126
clang::TargetInfo::getSigAtomicType
IntType getSigAtomicType() const
Definition: TargetInfo.h:360
clang::PreprocessorOptions::MacroIncludes
std::vector< std::string > MacroIncludes
Definition: PreprocessorOptions.h:68
DefineFmt
static void DefineFmt(const Twine &Prefix, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:183
clang::AtomicScopeOpenCLModel::Device
@ Device
Definition: SyncScope.h:116
clang::ShaderStage::Compute
@ Compute
clang::ShaderStage::Mesh
@ Mesh
clang::TargetInfo::getInt64Type
IntType getInt64Type() const
Definition: TargetInfo.h:352
clang::ObjCRuntime::isNonFragile
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:82
SyncScope.h
FileManager.h
clang::TransferrableTargetInfo::SignedShort
@ SignedShort
Definition: TargetInfo.h:120
PreprocessorOptions.h
clang::OpenCLOptions::isOpenCLOptionAvailableIn
static bool isOpenCLOptionAvailableIn(const LangOptions &LO, Args &&... args)
Definition: OpenCLOptions.h:195
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:131
clang::ShaderStage::Hull
@ Hull
clang::TypeSpecifierWidth::Short
@ Short
DefineTypeSizeAndWidth
static void DefineTypeSizeAndWidth(const Twine &Prefix, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:212
clang::MacroBuilder
Definition: MacroBuilder.h:23
clang::getClangFullCPPVersion
std::string getClangFullCPPVersion()
Retrieves a string representing the complete clang version suitable for use in the CPP VERSION macro,...
Definition: Version.cpp:108
clang::TargetInfo::getWCharType
IntType getWCharType() const
Definition: TargetInfo.h:348
InitializeStandardPredefinedMacros
static void InitializeStandardPredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:370
clang::PreprocessorOptions::Macros
std::vector< std::pair< std::string, bool > > Macros
Definition: PreprocessorOptions.h:66
clang::TransferrableTargetInfo::UnsignedInt
@ UnsignedInt
Definition: TargetInfo.h:123
clang::TypeSpecifierWidth::Long
@ Long
DefineTypeSizeof
static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth, const TargetInfo &TI, MacroBuilder &Builder)
Definition: InitPreprocessor.cpp:203
clang::TargetInfo::getIntWidth
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
Definition: TargetInfo.h:454
clang::PreprocessorOptions::ImplicitPCHInclude
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
Definition: PreprocessorOptions.h:96
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1536
clang::TransferrableTargetInfo::SignedLong
@ SignedLong
Definition: TargetInfo.h:124