Coverage Report

Created: 2022-07-16 07:03

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