Coverage Report

Created: 2023-05-31 04:38

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