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