clang 20.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, *NormMax, *Epsilon, *Max, *Min;
117 NormMax = PickFP(Sem, "6.5504e+4", "3.40282347e+38",
118 "1.7976931348623157e+308", "1.18973149535723176502e+4932",
119 "8.98846567431157953864652595394501e+307",
120 "1.18973149535723176508575932662800702e+4932");
121 DenormMin = PickFP(Sem, "5.9604644775390625e-8", "1.40129846e-45",
122 "4.9406564584124654e-324", "3.64519953188247460253e-4951",
123 "4.94065645841246544176568792868221e-324",
124 "6.47517511943802511092443895822764655e-4966");
125 int Digits = PickFP(Sem, 3, 6, 15, 18, 31, 33);
126 int DecimalDigits = PickFP(Sem, 5, 9, 17, 21, 33, 36);
127 Epsilon = PickFP(Sem, "9.765625e-4", "1.19209290e-7",
128 "2.2204460492503131e-16", "1.08420217248550443401e-19",
129 "4.94065645841246544176568792868221e-324",
130 "1.92592994438723585305597794258492732e-34");
131 int MantissaDigits = PickFP(Sem, 11, 24, 53, 64, 106, 113);
132 int Min10Exp = PickFP(Sem, -4, -37, -307, -4931, -291, -4931);
133 int Max10Exp = PickFP(Sem, 4, 38, 308, 4932, 308, 4932);
134 int MinExp = PickFP(Sem, -13, -125, -1021, -16381, -968, -16381);
135 int MaxExp = PickFP(Sem, 16, 128, 1024, 16384, 1024, 16384);
136 Min = PickFP(Sem, "6.103515625e-5", "1.17549435e-38", "2.2250738585072014e-308",
137 "3.36210314311209350626e-4932",
138 "2.00416836000897277799610805135016e-292",
139 "3.36210314311209350626267781732175260e-4932");
140 Max = PickFP(Sem, "6.5504e+4", "3.40282347e+38", "1.7976931348623157e+308",
141 "1.18973149535723176502e+4932",
142 "1.79769313486231580793728971405301e+308",
143 "1.18973149535723176508575932662800702e+4932");
144
145 SmallString<32> DefPrefix;
146 DefPrefix = "__";
147 DefPrefix += Prefix;
148 DefPrefix += "_";
149
150 Builder.defineMacro(DefPrefix + "DENORM_MIN__", Twine(DenormMin)+Ext);
151 Builder.defineMacro(DefPrefix + "NORM_MAX__", Twine(NormMax)+Ext);
152 Builder.defineMacro(DefPrefix + "HAS_DENORM__");
153 Builder.defineMacro(DefPrefix + "DIG__", Twine(Digits));
154 Builder.defineMacro(DefPrefix + "DECIMAL_DIG__", Twine(DecimalDigits));
155 Builder.defineMacro(DefPrefix + "EPSILON__", Twine(Epsilon)+Ext);
156 Builder.defineMacro(DefPrefix + "HAS_INFINITY__");
157 Builder.defineMacro(DefPrefix + "HAS_QUIET_NAN__");
158 Builder.defineMacro(DefPrefix + "MANT_DIG__", Twine(MantissaDigits));
159
160 Builder.defineMacro(DefPrefix + "MAX_10_EXP__", Twine(Max10Exp));
161 Builder.defineMacro(DefPrefix + "MAX_EXP__", Twine(MaxExp));
162 Builder.defineMacro(DefPrefix + "MAX__", Twine(Max)+Ext);
163
164 Builder.defineMacro(DefPrefix + "MIN_10_EXP__","("+Twine(Min10Exp)+")");
165 Builder.defineMacro(DefPrefix + "MIN_EXP__", "("+Twine(MinExp)+")");
166 Builder.defineMacro(DefPrefix + "MIN__", Twine(Min)+Ext);
167}
168
169
170/// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro
171/// named MacroName with the max value for a type with width 'TypeWidth' a
172/// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL).
173static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth,
174 StringRef ValSuffix, bool isSigned,
175 MacroBuilder &Builder) {
176 llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth)
177 : llvm::APInt::getMaxValue(TypeWidth);
178 Builder.defineMacro(MacroName, toString(MaxVal, 10, isSigned) + ValSuffix);
179}
180
181/// DefineTypeSize - An overloaded helper that uses TargetInfo to determine
182/// the width, suffix, and signedness of the given type
183static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty,
184 const TargetInfo &TI, MacroBuilder &Builder) {
185 DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty),
186 TI.isTypeSigned(Ty), Builder);
187}
188
189static void DefineFmt(const LangOptions &LangOpts, const Twine &Prefix,
190 TargetInfo::IntType Ty, const TargetInfo &TI,
191 MacroBuilder &Builder) {
192 StringRef FmtModifier = TI.getTypeFormatModifier(Ty);
193 auto Emitter = [&](char Fmt) {
194 Builder.defineMacro(Prefix + "_FMT" + Twine(Fmt) + "__",
195 Twine("\"") + FmtModifier + Twine(Fmt) + "\"");
196 };
197 bool IsSigned = TI.isTypeSigned(Ty);
198 llvm::for_each(StringRef(IsSigned ? "di" : "ouxX"), Emitter);
199
200 // C23 added the b and B modifiers for printing binary output of unsigned
201 // integers. Conditionally define those if compiling in C23 mode.
202 if (LangOpts.C23 && !IsSigned)
203 llvm::for_each(StringRef("bB"), Emitter);
204}
205
206static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty,
207 MacroBuilder &Builder) {
208 Builder.defineMacro(MacroName, TargetInfo::getTypeName(Ty));
209}
210
211static void DefineTypeWidth(const Twine &MacroName, TargetInfo::IntType Ty,
212 const TargetInfo &TI, MacroBuilder &Builder) {
213 Builder.defineMacro(MacroName, Twine(TI.getTypeWidth(Ty)));
214}
215
216static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth,
217 const TargetInfo &TI, MacroBuilder &Builder) {
218 Builder.defineMacro(MacroName,
219 Twine(BitWidth / TI.getCharWidth()));
220}
221
222// This will generate a macro based on the prefix with `_MAX__` as the suffix
223// for the max value representable for the type, and a macro with a `_WIDTH__`
224// suffix for the width of the type.
225static void DefineTypeSizeAndWidth(const Twine &Prefix, TargetInfo::IntType Ty,
226 const TargetInfo &TI,
227 MacroBuilder &Builder) {
228 DefineTypeSize(Prefix + "_MAX__", Ty, TI, Builder);
229 DefineTypeWidth(Prefix + "_WIDTH__", Ty, TI, Builder);
230}
231
232static void DefineExactWidthIntType(const LangOptions &LangOpts,
234 const TargetInfo &TI,
235 MacroBuilder &Builder) {
236 int TypeWidth = TI.getTypeWidth(Ty);
237 bool IsSigned = TI.isTypeSigned(Ty);
238
239 // Use the target specified int64 type, when appropriate, so that [u]int64_t
240 // ends up being defined in terms of the correct type.
241 if (TypeWidth == 64)
242 Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
243
244 // Use the target specified int16 type when appropriate. Some MCU targets
245 // (such as AVR) have definition of [u]int16_t to [un]signed int.
246 if (TypeWidth == 16)
247 Ty = IsSigned ? TI.getInt16Type() : TI.getUInt16Type();
248
249 const char *Prefix = IsSigned ? "__INT" : "__UINT";
250
251 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
252 DefineFmt(LangOpts, Prefix + Twine(TypeWidth), Ty, TI, Builder);
253
254 StringRef ConstSuffix(TI.getTypeConstantSuffix(Ty));
255 Builder.defineMacro(Prefix + Twine(TypeWidth) + "_C_SUFFIX__", ConstSuffix);
256 Builder.defineMacro(Prefix + Twine(TypeWidth) + "_C(c)",
257 ConstSuffix.size() ? Twine("c##") + ConstSuffix : "c");
258}
259
261 const TargetInfo &TI,
262 MacroBuilder &Builder) {
263 int TypeWidth = TI.getTypeWidth(Ty);
264 bool IsSigned = TI.isTypeSigned(Ty);
265
266 // Use the target specified int64 type, when appropriate, so that [u]int64_t
267 // ends up being defined in terms of the correct type.
268 if (TypeWidth == 64)
269 Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
270
271 // We don't need to define a _WIDTH macro for the exact-width types because
272 // we already know the width.
273 const char *Prefix = IsSigned ? "__INT" : "__UINT";
274 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
275}
276
277static void DefineLeastWidthIntType(const LangOptions &LangOpts,
278 unsigned TypeWidth, bool IsSigned,
279 const TargetInfo &TI,
280 MacroBuilder &Builder) {
281 TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
282 if (Ty == TargetInfo::NoInt)
283 return;
284
285 const char *Prefix = IsSigned ? "__INT_LEAST" : "__UINT_LEAST";
286 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
287 // We only want the *_WIDTH macro for the signed types to avoid too many
288 // predefined macros (the unsigned width and the signed width are identical.)
289 if (IsSigned)
290 DefineTypeSizeAndWidth(Prefix + Twine(TypeWidth), Ty, TI, Builder);
291 else
292 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
293 DefineFmt(LangOpts, Prefix + Twine(TypeWidth), Ty, TI, Builder);
294}
295
296static void DefineFastIntType(const LangOptions &LangOpts, unsigned TypeWidth,
297 bool IsSigned, const TargetInfo &TI,
298 MacroBuilder &Builder) {
299 // stdint.h currently defines the fast int types as equivalent to the least
300 // types.
301 TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
302 if (Ty == TargetInfo::NoInt)
303 return;
304
305 const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST";
306 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
307 // We only want the *_WIDTH macro for the signed types to avoid too many
308 // predefined macros (the unsigned width and the signed width are identical.)
309 if (IsSigned)
310 DefineTypeSizeAndWidth(Prefix + Twine(TypeWidth), Ty, TI, Builder);
311 else
312 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
313 DefineFmt(LangOpts, Prefix + Twine(TypeWidth), Ty, TI, Builder);
314}
315
316
317/// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with
318/// the specified properties.
319static const char *getLockFreeValue(unsigned TypeWidth, const TargetInfo &TI) {
320 // Fully-aligned, power-of-2 sizes no larger than the inline
321 // width will be inlined as lock-free operations.
322 // Note: we do not need to check alignment since _Atomic(T) is always
323 // appropriately-aligned in clang.
324 if (TI.hasBuiltinAtomic(TypeWidth, TypeWidth))
325 return "2"; // "always lock free"
326 // We cannot be certain what operations the lib calls might be
327 // able to implement as lock-free on future processors.
328 return "1"; // "sometimes lock free"
329}
330
331/// Add definitions required for a smooth interaction between
332/// Objective-C++ automated reference counting and libstdc++ (4.2).
333static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts,
334 MacroBuilder &Builder) {
335 Builder.defineMacro("_GLIBCXX_PREDEFINED_OBJC_ARC_IS_SCALAR");
336
337 std::string Result;
338 {
339 // Provide specializations for the __is_scalar type trait so that
340 // lifetime-qualified objects are not considered "scalar" types, which
341 // libstdc++ uses as an indicator of the presence of trivial copy, assign,
342 // default-construct, and destruct semantics (none of which hold for
343 // lifetime-qualified objects in ARC).
344 llvm::raw_string_ostream Out(Result);
345
346 Out << "namespace std {\n"
347 << "\n"
348 << "struct __true_type;\n"
349 << "struct __false_type;\n"
350 << "\n";
351
352 Out << "template<typename _Tp> struct __is_scalar;\n"
353 << "\n";
354
355 if (LangOpts.ObjCAutoRefCount) {
356 Out << "template<typename _Tp>\n"
357 << "struct __is_scalar<__attribute__((objc_ownership(strong))) _Tp> {\n"
358 << " enum { __value = 0 };\n"
359 << " typedef __false_type __type;\n"
360 << "};\n"
361 << "\n";
362 }
363
364 if (LangOpts.ObjCWeak) {
365 Out << "template<typename _Tp>\n"
366 << "struct __is_scalar<__attribute__((objc_ownership(weak))) _Tp> {\n"
367 << " enum { __value = 0 };\n"
368 << " typedef __false_type __type;\n"
369 << "};\n"
370 << "\n";
371 }
372
373 if (LangOpts.ObjCAutoRefCount) {
374 Out << "template<typename _Tp>\n"
375 << "struct __is_scalar<__attribute__((objc_ownership(autoreleasing)))"
376 << " _Tp> {\n"
377 << " enum { __value = 0 };\n"
378 << " typedef __false_type __type;\n"
379 << "};\n"
380 << "\n";
381 }
382
383 Out << "}\n";
384 }
385 Builder.append(Result);
386}
387
389 const LangOptions &LangOpts,
390 const FrontendOptions &FEOpts,
391 MacroBuilder &Builder) {
392 if (LangOpts.HLSL) {
393 Builder.defineMacro("__hlsl_clang");
394 // HLSL Version
395 Builder.defineMacro("__HLSL_VERSION",
396 Twine((unsigned)LangOpts.getHLSLVersion()));
397
398 if (LangOpts.NativeHalfType)
399 Builder.defineMacro("__HLSL_ENABLE_16_BIT", "1");
400
401 // Shader target information
402 // "enums" for shader stages
403 Builder.defineMacro("__SHADER_STAGE_VERTEX",
404 Twine((uint32_t)ShaderStage::Vertex));
405 Builder.defineMacro("__SHADER_STAGE_PIXEL",
406 Twine((uint32_t)ShaderStage::Pixel));
407 Builder.defineMacro("__SHADER_STAGE_GEOMETRY",
408 Twine((uint32_t)ShaderStage::Geometry));
409 Builder.defineMacro("__SHADER_STAGE_HULL",
410 Twine((uint32_t)ShaderStage::Hull));
411 Builder.defineMacro("__SHADER_STAGE_DOMAIN",
412 Twine((uint32_t)ShaderStage::Domain));
413 Builder.defineMacro("__SHADER_STAGE_COMPUTE",
414 Twine((uint32_t)ShaderStage::Compute));
415 Builder.defineMacro("__SHADER_STAGE_AMPLIFICATION",
416 Twine((uint32_t)ShaderStage::Amplification));
417 Builder.defineMacro("__SHADER_STAGE_MESH",
418 Twine((uint32_t)ShaderStage::Mesh));
419 Builder.defineMacro("__SHADER_STAGE_LIBRARY",
420 Twine((uint32_t)ShaderStage::Library));
421 // The current shader stage itself
422 uint32_t StageInteger = static_cast<uint32_t>(
423 hlsl::getStageFromEnvironment(TI.getTriple().getEnvironment()));
424
425 Builder.defineMacro("__SHADER_TARGET_STAGE", Twine(StageInteger));
426 // Add target versions
427 if (TI.getTriple().getOS() == llvm::Triple::ShaderModel) {
428 VersionTuple Version = TI.getTriple().getOSVersion();
429 Builder.defineMacro("__SHADER_TARGET_MAJOR", Twine(Version.getMajor()));
430 unsigned Minor = Version.getMinor().value_or(0);
431 Builder.defineMacro("__SHADER_TARGET_MINOR", Twine(Minor));
432 }
433 return;
434 }
435 // C++ [cpp.predefined]p1:
436 // The following macro names shall be defined by the implementation:
437
438 // -- __STDC__
439 // [C++] Whether __STDC__ is predefined and if so, what its value is,
440 // are implementation-defined.
441 // (Removed in C++20.)
442 if ((!LangOpts.MSVCCompat || LangOpts.MSVCEnableStdcMacro) &&
443 !LangOpts.TraditionalCPP)
444 Builder.defineMacro("__STDC__");
445 // -- __STDC_HOSTED__
446 // The integer literal 1 if the implementation is a hosted
447 // implementation or the integer literal 0 if it is not.
448 if (LangOpts.Freestanding)
449 Builder.defineMacro("__STDC_HOSTED__", "0");
450 else
451 Builder.defineMacro("__STDC_HOSTED__");
452
453 // -- __STDC_VERSION__
454 // [C++] Whether __STDC_VERSION__ is predefined and if so, what its
455 // value is, are implementation-defined.
456 // (Removed in C++20.)
457 if (!LangOpts.CPlusPlus) {
458 if (LangOpts.C2y)
459 Builder.defineMacro("__STDC_VERSION__", "202400L");
460 else if (LangOpts.C23)
461 Builder.defineMacro("__STDC_VERSION__", "202311L");
462 else if (LangOpts.C17)
463 Builder.defineMacro("__STDC_VERSION__", "201710L");
464 else if (LangOpts.C11)
465 Builder.defineMacro("__STDC_VERSION__", "201112L");
466 else if (LangOpts.C99)
467 Builder.defineMacro("__STDC_VERSION__", "199901L");
468 else if (!LangOpts.GNUMode && LangOpts.Digraphs)
469 Builder.defineMacro("__STDC_VERSION__", "199409L");
470 } else {
471 // -- __cplusplus
472 if (LangOpts.CPlusPlus26)
473 // FIXME: Use correct value for C++26.
474 Builder.defineMacro("__cplusplus", "202400L");
475 else if (LangOpts.CPlusPlus23)
476 Builder.defineMacro("__cplusplus", "202302L");
477 // [C++20] The integer literal 202002L.
478 else if (LangOpts.CPlusPlus20)
479 Builder.defineMacro("__cplusplus", "202002L");
480 // [C++17] The integer literal 201703L.
481 else if (LangOpts.CPlusPlus17)
482 Builder.defineMacro("__cplusplus", "201703L");
483 // [C++14] The name __cplusplus is defined to the value 201402L when
484 // compiling a C++ translation unit.
485 else if (LangOpts.CPlusPlus14)
486 Builder.defineMacro("__cplusplus", "201402L");
487 // [C++11] The name __cplusplus is defined to the value 201103L when
488 // compiling a C++ translation unit.
489 else if (LangOpts.CPlusPlus11)
490 Builder.defineMacro("__cplusplus", "201103L");
491 // [C++03] The name __cplusplus is defined to the value 199711L when
492 // compiling a C++ translation unit.
493 else
494 Builder.defineMacro("__cplusplus", "199711L");
495
496 // -- __STDCPP_DEFAULT_NEW_ALIGNMENT__
497 // [C++17] An integer literal of type std::size_t whose value is the
498 // alignment guaranteed by a call to operator new(std::size_t)
499 //
500 // We provide this in all language modes, since it seems generally useful.
501 Builder.defineMacro("__STDCPP_DEFAULT_NEW_ALIGNMENT__",
502 Twine(TI.getNewAlign() / TI.getCharWidth()) +
504
505 // -- __STDCPP_­THREADS__
506 // Defined, and has the value integer literal 1, if and only if a
507 // program can have more than one thread of execution.
508 if (LangOpts.getThreadModel() == LangOptions::ThreadModelKind::POSIX)
509 Builder.defineMacro("__STDCPP_THREADS__", "1");
510 }
511
512 // In C11 these are environment macros. In C++11 they are only defined
513 // as part of <cuchar>. To prevent breakage when mixing C and C++
514 // code, define these macros unconditionally. We can define them
515 // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit
516 // and 32-bit character literals.
517 Builder.defineMacro("__STDC_UTF_16__", "1");
518 Builder.defineMacro("__STDC_UTF_32__", "1");
519
520 // __has_embed definitions
521 Builder.defineMacro("__STDC_EMBED_NOT_FOUND__",
522 llvm::itostr(static_cast<int>(EmbedResult::NotFound)));
523 Builder.defineMacro("__STDC_EMBED_FOUND__",
524 llvm::itostr(static_cast<int>(EmbedResult::Found)));
525 Builder.defineMacro("__STDC_EMBED_EMPTY__",
526 llvm::itostr(static_cast<int>(EmbedResult::Empty)));
527
528 if (LangOpts.ObjC)
529 Builder.defineMacro("__OBJC__");
530
531 // OpenCL v1.0/1.1 s6.9, v1.2/2.0 s6.10: Preprocessor Directives and Macros.
532 if (LangOpts.OpenCL) {
533 if (LangOpts.CPlusPlus) {
534 switch (LangOpts.OpenCLCPlusPlusVersion) {
535 case 100:
536 Builder.defineMacro("__OPENCL_CPP_VERSION__", "100");
537 break;
538 case 202100:
539 Builder.defineMacro("__OPENCL_CPP_VERSION__", "202100");
540 break;
541 default:
542 llvm_unreachable("Unsupported C++ version for OpenCL");
543 }
544 Builder.defineMacro("__CL_CPP_VERSION_1_0__", "100");
545 Builder.defineMacro("__CL_CPP_VERSION_2021__", "202100");
546 } else {
547 // OpenCL v1.0 and v1.1 do not have a predefined macro to indicate the
548 // language standard with which the program is compiled. __OPENCL_VERSION__
549 // is for the OpenCL version supported by the OpenCL device, which is not
550 // necessarily the language standard with which the program is compiled.
551 // A shared OpenCL header file requires a macro to indicate the language
552 // standard. As a workaround, __OPENCL_C_VERSION__ is defined for
553 // OpenCL v1.0 and v1.1.
554 switch (LangOpts.OpenCLVersion) {
555 case 100:
556 Builder.defineMacro("__OPENCL_C_VERSION__", "100");
557 break;
558 case 110:
559 Builder.defineMacro("__OPENCL_C_VERSION__", "110");
560 break;
561 case 120:
562 Builder.defineMacro("__OPENCL_C_VERSION__", "120");
563 break;
564 case 200:
565 Builder.defineMacro("__OPENCL_C_VERSION__", "200");
566 break;
567 case 300:
568 Builder.defineMacro("__OPENCL_C_VERSION__", "300");
569 break;
570 default:
571 llvm_unreachable("Unsupported OpenCL version");
572 }
573 }
574 Builder.defineMacro("CL_VERSION_1_0", "100");
575 Builder.defineMacro("CL_VERSION_1_1", "110");
576 Builder.defineMacro("CL_VERSION_1_2", "120");
577 Builder.defineMacro("CL_VERSION_2_0", "200");
578 Builder.defineMacro("CL_VERSION_3_0", "300");
579
580 if (TI.isLittleEndian())
581 Builder.defineMacro("__ENDIAN_LITTLE__");
582
583 if (LangOpts.FastRelaxedMath)
584 Builder.defineMacro("__FAST_RELAXED_MATH__");
585 }
586
587 if (LangOpts.SYCLIsDevice || LangOpts.SYCLIsHost) {
588 // SYCL Version is set to a value when building SYCL applications
589 if (LangOpts.getSYCLVersion() == LangOptions::SYCL_2017)
590 Builder.defineMacro("CL_SYCL_LANGUAGE_VERSION", "121");
591 else if (LangOpts.getSYCLVersion() == LangOptions::SYCL_2020)
592 Builder.defineMacro("SYCL_LANGUAGE_VERSION", "202012L");
593 }
594
595 // Not "standard" per se, but available even with the -undef flag.
596 if (LangOpts.AsmPreprocessor)
597 Builder.defineMacro("__ASSEMBLER__");
598 if (LangOpts.CUDA) {
599 if (LangOpts.GPURelocatableDeviceCode)
600 Builder.defineMacro("__CLANG_RDC__");
601 if (!LangOpts.HIP)
602 Builder.defineMacro("__CUDA__");
603 if (LangOpts.GPUDefaultStream ==
604 LangOptions::GPUDefaultStreamKind::PerThread)
605 Builder.defineMacro("CUDA_API_PER_THREAD_DEFAULT_STREAM");
606 }
607 if (LangOpts.HIP) {
608 Builder.defineMacro("__HIP__");
609 Builder.defineMacro("__HIPCC__");
610 Builder.defineMacro("__HIP_MEMORY_SCOPE_SINGLETHREAD", "1");
611 Builder.defineMacro("__HIP_MEMORY_SCOPE_WAVEFRONT", "2");
612 Builder.defineMacro("__HIP_MEMORY_SCOPE_WORKGROUP", "3");
613 Builder.defineMacro("__HIP_MEMORY_SCOPE_AGENT", "4");
614 Builder.defineMacro("__HIP_MEMORY_SCOPE_SYSTEM", "5");
615 if (LangOpts.HIPStdPar) {
616 Builder.defineMacro("__HIPSTDPAR__");
617 if (LangOpts.HIPStdParInterposeAlloc)
618 Builder.defineMacro("__HIPSTDPAR_INTERPOSE_ALLOC__");
619 }
620 if (LangOpts.CUDAIsDevice) {
621 Builder.defineMacro("__HIP_DEVICE_COMPILE__");
622 if (!TI.hasHIPImageSupport()) {
623 Builder.defineMacro("__HIP_NO_IMAGE_SUPPORT__", "1");
624 // Deprecated.
625 Builder.defineMacro("__HIP_NO_IMAGE_SUPPORT", "1");
626 }
627 }
628 if (LangOpts.GPUDefaultStream ==
629 LangOptions::GPUDefaultStreamKind::PerThread) {
630 Builder.defineMacro("__HIP_API_PER_THREAD_DEFAULT_STREAM__");
631 // Deprecated.
632 Builder.defineMacro("HIP_API_PER_THREAD_DEFAULT_STREAM");
633 }
634 }
635
636 if (LangOpts.OpenACC) {
637 // FIXME: When we have full support for OpenACC, we should set this to the
638 // version we support. Until then, set as '1' by default, but provide a
639 // temporary mechanism for users to override this so real-world examples can
640 // be tested against.
641 if (!LangOpts.OpenACCMacroOverride.empty())
642 Builder.defineMacro("_OPENACC", LangOpts.OpenACCMacroOverride);
643 else
644 Builder.defineMacro("_OPENACC", "1");
645 }
646}
647
648/// Initialize the predefined C++ language feature test macros defined in
649/// ISO/IEC JTC1/SC22/WG21 (C++) SD-6: "SG10 Feature Test Recommendations".
651 MacroBuilder &Builder) {
652 // C++98 features.
653 if (LangOpts.RTTI)
654 Builder.defineMacro("__cpp_rtti", "199711L");
655 if (LangOpts.CXXExceptions)
656 Builder.defineMacro("__cpp_exceptions", "199711L");
657
658 // C++11 features.
659 if (LangOpts.CPlusPlus11) {
660 Builder.defineMacro("__cpp_unicode_characters", "200704L");
661 Builder.defineMacro("__cpp_raw_strings", "200710L");
662 Builder.defineMacro("__cpp_unicode_literals", "200710L");
663 Builder.defineMacro("__cpp_user_defined_literals", "200809L");
664 Builder.defineMacro("__cpp_lambdas", "200907L");
665 Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus26 ? "202406L"
666 : LangOpts.CPlusPlus23 ? "202211L"
667 : LangOpts.CPlusPlus20 ? "201907L"
668 : LangOpts.CPlusPlus17 ? "201603L"
669 : LangOpts.CPlusPlus14 ? "201304L"
670 : "200704");
671 Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L");
672 Builder.defineMacro("__cpp_range_based_for",
673 LangOpts.CPlusPlus23 ? "202211L"
674 : LangOpts.CPlusPlus17 ? "201603L"
675 : "200907");
676 // C++17 / C++26 static_assert supported as an extension in earlier language
677 // modes, so we use the C++26 value.
678 Builder.defineMacro("__cpp_static_assert", "202306L");
679 Builder.defineMacro("__cpp_decltype", "200707L");
680 Builder.defineMacro("__cpp_attributes", "200809L");
681 Builder.defineMacro("__cpp_rvalue_references", "200610L");
682 Builder.defineMacro("__cpp_variadic_templates", "200704L");
683 Builder.defineMacro("__cpp_initializer_lists", "200806L");
684 Builder.defineMacro("__cpp_delegating_constructors", "200604L");
685 Builder.defineMacro("__cpp_nsdmi", "200809L");
686 Builder.defineMacro("__cpp_inheriting_constructors", "201511L");
687 Builder.defineMacro("__cpp_ref_qualifiers", "200710L");
688 Builder.defineMacro("__cpp_alias_templates", "200704L");
689 }
690 if (LangOpts.ThreadsafeStatics)
691 Builder.defineMacro("__cpp_threadsafe_static_init", "200806L");
692
693 // C++14 features.
694 if (LangOpts.CPlusPlus14) {
695 Builder.defineMacro("__cpp_binary_literals", "201304L");
696 Builder.defineMacro("__cpp_digit_separators", "201309L");
697 Builder.defineMacro("__cpp_init_captures",
698 LangOpts.CPlusPlus20 ? "201803L" : "201304L");
699 Builder.defineMacro("__cpp_generic_lambdas",
700 LangOpts.CPlusPlus20 ? "201707L" : "201304L");
701 Builder.defineMacro("__cpp_decltype_auto", "201304L");
702 Builder.defineMacro("__cpp_return_type_deduction", "201304L");
703 Builder.defineMacro("__cpp_aggregate_nsdmi", "201304L");
704 Builder.defineMacro("__cpp_variable_templates", "201304L");
705 }
706 if (LangOpts.SizedDeallocation)
707 Builder.defineMacro("__cpp_sized_deallocation", "201309L");
708
709 // C++17 features.
710 if (LangOpts.CPlusPlus17) {
711 Builder.defineMacro("__cpp_hex_float", "201603L");
712 Builder.defineMacro("__cpp_inline_variables", "201606L");
713 Builder.defineMacro("__cpp_noexcept_function_type", "201510L");
714 Builder.defineMacro("__cpp_capture_star_this", "201603L");
715 Builder.defineMacro("__cpp_if_constexpr", "201606L");
716 Builder.defineMacro("__cpp_deduction_guides", "201703L"); // (not latest)
717 Builder.defineMacro("__cpp_template_auto", "201606L"); // (old name)
718 Builder.defineMacro("__cpp_namespace_attributes", "201411L");
719 Builder.defineMacro("__cpp_enumerator_attributes", "201411L");
720 Builder.defineMacro("__cpp_nested_namespace_definitions", "201411L");
721 Builder.defineMacro("__cpp_variadic_using", "201611L");
722 Builder.defineMacro("__cpp_aggregate_bases", "201603L");
723 Builder.defineMacro("__cpp_structured_bindings", "202403L");
724 Builder.defineMacro("__cpp_nontype_template_args",
725 "201411L"); // (not latest)
726 Builder.defineMacro("__cpp_fold_expressions", "201603L");
727 Builder.defineMacro("__cpp_guaranteed_copy_elision", "201606L");
728 Builder.defineMacro("__cpp_nontype_template_parameter_auto", "201606L");
729 }
730 if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)
731 Builder.defineMacro("__cpp_aligned_new", "201606L");
732 if (LangOpts.RelaxedTemplateTemplateArgs)
733 Builder.defineMacro("__cpp_template_template_args", "201611L");
734
735 // C++20 features.
736 if (LangOpts.CPlusPlus20) {
737 Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");
738
739 Builder.defineMacro("__cpp_concepts", "202002");
740 Builder.defineMacro("__cpp_conditional_explicit", "201806L");
741 Builder.defineMacro("__cpp_consteval", "202211L");
742 Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");
743 Builder.defineMacro("__cpp_constinit", "201907L");
744 Builder.defineMacro("__cpp_impl_coroutine", "201902L");
745 Builder.defineMacro("__cpp_designated_initializers", "201707L");
746 Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");
747 //Builder.defineMacro("__cpp_modules", "201907L");
748 Builder.defineMacro("__cpp_using_enum", "201907L");
749 }
750 // C++23 features.
751 if (LangOpts.CPlusPlus23) {
752 Builder.defineMacro("__cpp_implicit_move", "202207L");
753 Builder.defineMacro("__cpp_size_t_suffix", "202011L");
754 Builder.defineMacro("__cpp_if_consteval", "202106L");
755 Builder.defineMacro("__cpp_multidimensional_subscript", "202211L");
756 Builder.defineMacro("__cpp_auto_cast", "202110L");
757 Builder.defineMacro("__cpp_explicit_this_parameter", "202110L");
758 }
759
760 // We provide those C++23 features as extensions in earlier language modes, so
761 // we also define their feature test macros.
762 if (LangOpts.CPlusPlus11)
763 Builder.defineMacro("__cpp_static_call_operator", "202207L");
764 Builder.defineMacro("__cpp_named_character_escapes", "202207L");
765 Builder.defineMacro("__cpp_placeholder_variables", "202306L");
766
767 // C++26 features supported in earlier language modes.
768 Builder.defineMacro("__cpp_pack_indexing", "202311L");
769 Builder.defineMacro("__cpp_deleted_function", "202403L");
770 Builder.defineMacro("__cpp_variadic_friend", "202403L");
771
772 if (LangOpts.Char8)
773 Builder.defineMacro("__cpp_char8_t", "202207L");
774 Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
775}
776
777/// InitializeOpenCLFeatureTestMacros - Define OpenCL macros based on target
778/// settings and language version
780 const LangOptions &Opts,
781 MacroBuilder &Builder) {
782 const llvm::StringMap<bool> &OpenCLFeaturesMap = TI.getSupportedOpenCLOpts();
783 // FIXME: OpenCL options which affect language semantics/syntax
784 // should be moved into LangOptions.
785 auto defineOpenCLExtMacro = [&](llvm::StringRef Name, auto... OptArgs) {
786 // Check if extension is supported by target and is available in this
787 // OpenCL version
788 if (TI.hasFeatureEnabled(OpenCLFeaturesMap, Name) &&
790 Builder.defineMacro(Name);
791 };
792#define OPENCL_GENERIC_EXTENSION(Ext, ...) \
793 defineOpenCLExtMacro(#Ext, __VA_ARGS__);
794#include "clang/Basic/OpenCLExtensions.def"
795
796 // Assume compiling for FULL profile
797 Builder.defineMacro("__opencl_c_int64");
798}
799
801 llvm::StringRef Suffix) {
802 if (Val.isSigned() && Val == llvm::APFixedPoint::getMin(Val.getSemantics())) {
803 // When representing the min value of a signed fixed point type in source
804 // code, we cannot simply write `-<lowest value>`. For example, the min
805 // value of a `short _Fract` cannot be written as `-1.0hr`. This is because
806 // the parser will read this (and really any negative numerical literal) as
807 // a UnaryOperator that owns a FixedPointLiteral with a positive value
808 // rather than just a FixedPointLiteral with a negative value. Compiling
809 // `-1.0hr` results in an overflow to the maximal value of that fixed point
810 // type. The correct way to represent a signed min value is to instead split
811 // it into two halves, like `(-0.5hr-0.5hr)` which is what the standard
812 // defines SFRACT_MIN as.
813 llvm::SmallString<32> Literal;
814 Literal.push_back('(');
815 llvm::SmallString<32> HalfStr =
816 ConstructFixedPointLiteral(Val.shr(1), Suffix);
817 Literal += HalfStr;
818 Literal += HalfStr;
819 Literal.push_back(')');
820 return Literal;
821 }
822
823 llvm::SmallString<32> Str(Val.toString());
824 Str += Suffix;
825 return Str;
826}
827
829 llvm::StringRef TypeName, llvm::StringRef Suffix,
830 unsigned Width, unsigned Scale, bool Signed) {
831 // Saturation doesn't affect the size or scale of a fixed point type, so we
832 // don't need it here.
833 llvm::FixedPointSemantics FXSema(
834 Width, Scale, Signed, /*IsSaturated=*/false,
836 llvm::SmallString<32> MacroPrefix("__");
837 MacroPrefix += TypeName;
838 Builder.defineMacro(MacroPrefix + "_EPSILON__",
840 llvm::APFixedPoint::getEpsilon(FXSema), Suffix));
841 Builder.defineMacro(MacroPrefix + "_FBIT__", Twine(Scale));
842 Builder.defineMacro(
843 MacroPrefix + "_MAX__",
844 ConstructFixedPointLiteral(llvm::APFixedPoint::getMax(FXSema), Suffix));
845
846 // ISO/IEC TR 18037:2008 doesn't specify MIN macros for unsigned types since
847 // they're all just zero.
848 if (Signed)
849 Builder.defineMacro(
850 MacroPrefix + "_MIN__",
851 ConstructFixedPointLiteral(llvm::APFixedPoint::getMin(FXSema), Suffix));
852}
853
855 const LangOptions &LangOpts,
856 const FrontendOptions &FEOpts,
857 const PreprocessorOptions &PPOpts,
858 MacroBuilder &Builder) {
859 // Compiler version introspection macros.
860 Builder.defineMacro("__llvm__"); // LLVM Backend
861 Builder.defineMacro("__clang__"); // Clang Frontend
862#define TOSTR2(X) #X
863#define TOSTR(X) TOSTR2(X)
864 Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR));
865 Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR));
866 Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL));
867#undef TOSTR
868#undef TOSTR2
869 Builder.defineMacro("__clang_version__",
870 "\"" CLANG_VERSION_STRING " "
872
873 if (LangOpts.GNUCVersion != 0) {
874 // Major, minor, patch, are given two decimal places each, so 4.2.1 becomes
875 // 40201.
876 unsigned GNUCMajor = LangOpts.GNUCVersion / 100 / 100;
877 unsigned GNUCMinor = LangOpts.GNUCVersion / 100 % 100;
878 unsigned GNUCPatch = LangOpts.GNUCVersion % 100;
879 Builder.defineMacro("__GNUC__", Twine(GNUCMajor));
880 Builder.defineMacro("__GNUC_MINOR__", Twine(GNUCMinor));
881 Builder.defineMacro("__GNUC_PATCHLEVEL__", Twine(GNUCPatch));
882 Builder.defineMacro("__GXX_ABI_VERSION", "1002");
883
884 if (LangOpts.CPlusPlus) {
885 Builder.defineMacro("__GNUG__", Twine(GNUCMajor));
886 Builder.defineMacro("__GXX_WEAK__");
887 }
888 }
889
890 // Define macros for the C11 / C++11 memory orderings
891 Builder.defineMacro("__ATOMIC_RELAXED", "0");
892 Builder.defineMacro("__ATOMIC_CONSUME", "1");
893 Builder.defineMacro("__ATOMIC_ACQUIRE", "2");
894 Builder.defineMacro("__ATOMIC_RELEASE", "3");
895 Builder.defineMacro("__ATOMIC_ACQ_REL", "4");
896 Builder.defineMacro("__ATOMIC_SEQ_CST", "5");
897
898 // Define macros for the clang atomic scopes.
899 Builder.defineMacro("__MEMORY_SCOPE_SYSTEM", "0");
900 Builder.defineMacro("__MEMORY_SCOPE_DEVICE", "1");
901 Builder.defineMacro("__MEMORY_SCOPE_WRKGRP", "2");
902 Builder.defineMacro("__MEMORY_SCOPE_WVFRNT", "3");
903 Builder.defineMacro("__MEMORY_SCOPE_SINGLE", "4");
904
905 // Define macros for the OpenCL memory scope.
906 // The values should match AtomicScopeOpenCLModel::ID enum.
907 static_assert(
908 static_cast<unsigned>(AtomicScopeOpenCLModel::WorkGroup) == 1 &&
909 static_cast<unsigned>(AtomicScopeOpenCLModel::Device) == 2 &&
910 static_cast<unsigned>(AtomicScopeOpenCLModel::AllSVMDevices) == 3 &&
911 static_cast<unsigned>(AtomicScopeOpenCLModel::SubGroup) == 4,
912 "Invalid OpenCL memory scope enum definition");
913 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_ITEM", "0");
914 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_GROUP", "1");
915 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_DEVICE", "2");
916 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES", "3");
917 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_SUB_GROUP", "4");
918
919 // Define macros for floating-point data classes, used in __builtin_isfpclass.
920 Builder.defineMacro("__FPCLASS_SNAN", "0x0001");
921 Builder.defineMacro("__FPCLASS_QNAN", "0x0002");
922 Builder.defineMacro("__FPCLASS_NEGINF", "0x0004");
923 Builder.defineMacro("__FPCLASS_NEGNORMAL", "0x0008");
924 Builder.defineMacro("__FPCLASS_NEGSUBNORMAL", "0x0010");
925 Builder.defineMacro("__FPCLASS_NEGZERO", "0x0020");
926 Builder.defineMacro("__FPCLASS_POSZERO", "0x0040");
927 Builder.defineMacro("__FPCLASS_POSSUBNORMAL", "0x0080");
928 Builder.defineMacro("__FPCLASS_POSNORMAL", "0x0100");
929 Builder.defineMacro("__FPCLASS_POSINF", "0x0200");
930
931 // Support for #pragma redefine_extname (Sun compatibility)
932 Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");
933
934 // Previously this macro was set to a string aiming to achieve compatibility
935 // with GCC 4.2.1. Now, just return the full Clang version
936 Builder.defineMacro("__VERSION__", "\"" +
937 Twine(getClangFullCPPVersion()) + "\"");
938
939 // Initialize language-specific preprocessor defines.
940
941 // Standard conforming mode?
942 if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)
943 Builder.defineMacro("__STRICT_ANSI__");
944
945 if (LangOpts.GNUCVersion && LangOpts.CPlusPlus11)
946 Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");
947
948 if (TI.getTriple().isWindowsGNUEnvironment()) {
949 // Set ABI defining macros for libstdc++ for MinGW, where the
950 // default in libstdc++ differs from the defaults for this target.
951 Builder.defineMacro("__GXX_TYPEINFO_EQUALITY_INLINE", "0");
952 }
953
954 if (LangOpts.ObjC) {
955 if (LangOpts.ObjCRuntime.isNonFragile()) {
956 Builder.defineMacro("__OBJC2__");
957
958 if (LangOpts.ObjCExceptions)
959 Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS");
960 }
961
962 if (LangOpts.getGC() != LangOptions::NonGC)
963 Builder.defineMacro("__OBJC_GC__");
964
965 if (LangOpts.ObjCRuntime.isNeXTFamily())
966 Builder.defineMacro("__NEXT_RUNTIME__");
967
968 if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::GNUstep) {
969 auto version = LangOpts.ObjCRuntime.getVersion();
970 std::string versionString = "1";
971 // Don't rely on the tuple argument, because we can be asked to target
972 // later ABIs than we actually support, so clamp these values to those
973 // currently supported
974 if (version >= VersionTuple(2, 0))
975 Builder.defineMacro("__OBJC_GNUSTEP_RUNTIME_ABI__", "20");
976 else
977 Builder.defineMacro(
978 "__OBJC_GNUSTEP_RUNTIME_ABI__",
979 "1" + Twine(std::min(8U, version.getMinor().value_or(0))));
980 }
981
982 if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::ObjFW) {
983 VersionTuple tuple = LangOpts.ObjCRuntime.getVersion();
984 unsigned minor = tuple.getMinor().value_or(0);
985 unsigned subminor = tuple.getSubminor().value_or(0);
986 Builder.defineMacro("__OBJFW_RUNTIME_ABI__",
987 Twine(tuple.getMajor() * 10000 + minor * 100 +
988 subminor));
989 }
990
991 Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))");
992 Builder.defineMacro("IBOutletCollection(ClassName)",
993 "__attribute__((iboutletcollection(ClassName)))");
994 Builder.defineMacro("IBAction", "void)__attribute__((ibaction)");
995 Builder.defineMacro("IBInspectable", "");
996 Builder.defineMacro("IB_DESIGNABLE", "");
997 }
998
999 // Define a macro that describes the Objective-C boolean type even for C
1000 // and C++ since BOOL can be used from non Objective-C code.
1001 Builder.defineMacro("__OBJC_BOOL_IS_BOOL",
1002 Twine(TI.useSignedCharForObjCBool() ? "0" : "1"));
1003
1004 if (LangOpts.CPlusPlus)
1005 InitializeCPlusPlusFeatureTestMacros(LangOpts, Builder);
1006
1007 // darwin_constant_cfstrings controls this. This is also dependent
1008 // on other things like the runtime I believe. This is set even for C code.
1009 if (!LangOpts.NoConstantCFStrings)
1010 Builder.defineMacro("__CONSTANT_CFSTRINGS__");
1011
1012 if (LangOpts.ObjC)
1013 Builder.defineMacro("OBJC_NEW_PROPERTIES");
1014
1015 if (LangOpts.PascalStrings)
1016 Builder.defineMacro("__PASCAL_STRINGS__");
1017
1018 if (LangOpts.Blocks) {
1019 Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");
1020 Builder.defineMacro("__BLOCKS__");
1021 }
1022
1023 if (!LangOpts.MSVCCompat && LangOpts.Exceptions)
1024 Builder.defineMacro("__EXCEPTIONS");
1025 if (LangOpts.GNUCVersion && LangOpts.RTTI)
1026 Builder.defineMacro("__GXX_RTTI");
1027
1028 if (LangOpts.hasSjLjExceptions())
1029 Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
1030 else if (LangOpts.hasSEHExceptions())
1031 Builder.defineMacro("__SEH__");
1032 else if (LangOpts.hasDWARFExceptions() &&
1033 (TI.getTriple().isThumb() || TI.getTriple().isARM()))
1034 Builder.defineMacro("__ARM_DWARF_EH__");
1035 else if (LangOpts.hasWasmExceptions() && TI.getTriple().isWasm())
1036 Builder.defineMacro("__WASM_EXCEPTIONS__");
1037
1038 if (LangOpts.Deprecated)
1039 Builder.defineMacro("__DEPRECATED");
1040
1041 if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus)
1042 Builder.defineMacro("__private_extern__", "extern");
1043
1044 if (LangOpts.MicrosoftExt) {
1045 if (LangOpts.WChar) {
1046 // wchar_t supported as a keyword.
1047 Builder.defineMacro("_WCHAR_T_DEFINED");
1048 Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED");
1049 }
1050 }
1051
1052 // Macros to help identify the narrow and wide character sets
1053 // FIXME: clang currently ignores -fexec-charset=. If this changes,
1054 // then this may need to be updated.
1055 Builder.defineMacro("__clang_literal_encoding__", "\"UTF-8\"");
1056 if (TI.getTypeWidth(TI.getWCharType()) >= 32) {
1057 // FIXME: 32-bit wchar_t signals UTF-32. This may change
1058 // if -fwide-exec-charset= is ever supported.
1059 Builder.defineMacro("__clang_wide_literal_encoding__", "\"UTF-32\"");
1060 } else {
1061 // FIXME: Less-than 32-bit wchar_t generally means UTF-16
1062 // (e.g., Windows, 32-bit IBM). This may need to be
1063 // updated if -fwide-exec-charset= is ever supported.
1064 Builder.defineMacro("__clang_wide_literal_encoding__", "\"UTF-16\"");
1065 }
1066
1067 if (LangOpts.Optimize)
1068 Builder.defineMacro("__OPTIMIZE__");
1069 if (LangOpts.OptimizeSize)
1070 Builder.defineMacro("__OPTIMIZE_SIZE__");
1071
1072 if (LangOpts.FastMath)
1073 Builder.defineMacro("__FAST_MATH__");
1074
1075 // Initialize target-specific preprocessor defines.
1076
1077 // __BYTE_ORDER__ was added in GCC 4.6. It's analogous
1078 // to the macro __BYTE_ORDER (no trailing underscores)
1079 // from glibc's <endian.h> header.
1080 // We don't support the PDP-11 as a target, but include
1081 // the define so it can still be compared against.
1082 Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234");
1083 Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321");
1084 Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412");
1085 if (TI.isBigEndian()) {
1086 Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__");
1087 Builder.defineMacro("__BIG_ENDIAN__");
1088 } else {
1089 Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__");
1090 Builder.defineMacro("__LITTLE_ENDIAN__");
1091 }
1092
1093 if (TI.getPointerWidth(LangAS::Default) == 64 && TI.getLongWidth() == 64 &&
1094 TI.getIntWidth() == 32) {
1095 Builder.defineMacro("_LP64");
1096 Builder.defineMacro("__LP64__");
1097 }
1098
1099 if (TI.getPointerWidth(LangAS::Default) == 32 && TI.getLongWidth() == 32 &&
1100 TI.getIntWidth() == 32) {
1101 Builder.defineMacro("_ILP32");
1102 Builder.defineMacro("__ILP32__");
1103 }
1104
1105 // Define type sizing macros based on the target properties.
1106 assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");
1107 Builder.defineMacro("__CHAR_BIT__", Twine(TI.getCharWidth()));
1108
1109 // The macro is specifying the number of bits in the width, not the number of
1110 // bits the object requires for its in-memory representation, which is what
1111 // getBoolWidth() will return. The bool/_Bool data type is only ever one bit
1112 // wide. See C23 6.2.6.2p2 for the rules in C. Note that
1113 // C++23 [basic.fundamental]p10 allows an implementation-defined value
1114 // representation for bool; when lowering to LLVM, Clang represents bool as an
1115 // i8 in memory but as an i1 when the value is needed, so '1' is also correct
1116 // for C++.
1117 Builder.defineMacro("__BOOL_WIDTH__", "1");
1118 Builder.defineMacro("__SHRT_WIDTH__", Twine(TI.getShortWidth()));
1119 Builder.defineMacro("__INT_WIDTH__", Twine(TI.getIntWidth()));
1120 Builder.defineMacro("__LONG_WIDTH__", Twine(TI.getLongWidth()));
1121 Builder.defineMacro("__LLONG_WIDTH__", Twine(TI.getLongLongWidth()));
1122
1123 size_t BitIntMaxWidth = TI.getMaxBitIntWidth();
1124 assert(BitIntMaxWidth <= llvm::IntegerType::MAX_INT_BITS &&
1125 "Target defined a max bit width larger than LLVM can support!");
1126 assert(BitIntMaxWidth >= TI.getLongLongWidth() &&
1127 "Target defined a max bit width smaller than the C standard allows!");
1128 Builder.defineMacro("__BITINT_MAXWIDTH__", Twine(BitIntMaxWidth));
1129
1130 DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder);
1131 DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder);
1132 DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder);
1133 DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder);
1134 DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder);
1135 DefineTypeSizeAndWidth("__WCHAR", TI.getWCharType(), TI, Builder);
1136 DefineTypeSizeAndWidth("__WINT", TI.getWIntType(), TI, Builder);
1137 DefineTypeSizeAndWidth("__INTMAX", TI.getIntMaxType(), TI, Builder);
1138 DefineTypeSizeAndWidth("__SIZE", TI.getSizeType(), TI, Builder);
1139
1140 DefineTypeSizeAndWidth("__UINTMAX", TI.getUIntMaxType(), TI, Builder);
1141 DefineTypeSizeAndWidth("__PTRDIFF", TI.getPtrDiffType(LangAS::Default), TI,
1142 Builder);
1143 DefineTypeSizeAndWidth("__INTPTR", TI.getIntPtrType(), TI, Builder);
1144 DefineTypeSizeAndWidth("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
1145
1146 DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder);
1147 DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder);
1148 DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder);
1149 DefineTypeSizeof("__SIZEOF_LONG__", TI.getLongWidth(), TI, Builder);
1150 DefineTypeSizeof("__SIZEOF_LONG_DOUBLE__",TI.getLongDoubleWidth(),TI,Builder);
1151 DefineTypeSizeof("__SIZEOF_LONG_LONG__", TI.getLongLongWidth(), TI, Builder);
1152 DefineTypeSizeof("__SIZEOF_POINTER__", TI.getPointerWidth(LangAS::Default),
1153 TI, Builder);
1154 DefineTypeSizeof("__SIZEOF_SHORT__", TI.getShortWidth(), TI, Builder);
1155 DefineTypeSizeof("__SIZEOF_PTRDIFF_T__",
1156 TI.getTypeWidth(TI.getPtrDiffType(LangAS::Default)), TI,
1157 Builder);
1158 DefineTypeSizeof("__SIZEOF_SIZE_T__",
1159 TI.getTypeWidth(TI.getSizeType()), TI, Builder);
1160 DefineTypeSizeof("__SIZEOF_WCHAR_T__",
1161 TI.getTypeWidth(TI.getWCharType()), TI, Builder);
1162 DefineTypeSizeof("__SIZEOF_WINT_T__",
1163 TI.getTypeWidth(TI.getWIntType()), TI, Builder);
1164 if (TI.hasInt128Type())
1165 DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder);
1166
1167 DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder);
1168 DefineFmt(LangOpts, "__INTMAX", TI.getIntMaxType(), TI, Builder);
1169 StringRef ConstSuffix(TI.getTypeConstantSuffix(TI.getIntMaxType()));
1170 Builder.defineMacro("__INTMAX_C_SUFFIX__", ConstSuffix);
1171 Builder.defineMacro("__INTMAX_C(c)",
1172 ConstSuffix.size() ? Twine("c##") + ConstSuffix : "c");
1173 DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder);
1174 DefineFmt(LangOpts, "__UINTMAX", TI.getUIntMaxType(), TI, Builder);
1175 ConstSuffix = TI.getTypeConstantSuffix(TI.getUIntMaxType());
1176 Builder.defineMacro("__UINTMAX_C_SUFFIX__", ConstSuffix);
1177 Builder.defineMacro("__UINTMAX_C(c)",
1178 ConstSuffix.size() ? Twine("c##") + ConstSuffix : "c");
1179 DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(LangAS::Default), Builder);
1180 DefineFmt(LangOpts, "__PTRDIFF", TI.getPtrDiffType(LangAS::Default), TI,
1181 Builder);
1182 DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder);
1183 DefineFmt(LangOpts, "__INTPTR", TI.getIntPtrType(), TI, Builder);
1184 DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder);
1185 DefineFmt(LangOpts, "__SIZE", TI.getSizeType(), TI, Builder);
1186 DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder);
1187 DefineType("__WINT_TYPE__", TI.getWIntType(), Builder);
1188 DefineTypeSizeAndWidth("__SIG_ATOMIC", TI.getSigAtomicType(), TI, Builder);
1189 if (LangOpts.C23)
1190 DefineType("__CHAR8_TYPE__", TI.UnsignedChar, Builder);
1191 DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder);
1192 DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder);
1193
1194 DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder);
1195 DefineFmt(LangOpts, "__UINTPTR", TI.getUIntPtrType(), TI, Builder);
1196
1197 // The C standard requires the width of uintptr_t and intptr_t to be the same,
1198 // per 7.20.2.4p1. Same for intmax_t and uintmax_t, per 7.20.2.5p1.
1199 assert(TI.getTypeWidth(TI.getUIntPtrType()) ==
1200 TI.getTypeWidth(TI.getIntPtrType()) &&
1201 "uintptr_t and intptr_t have different widths?");
1202 assert(TI.getTypeWidth(TI.getUIntMaxType()) ==
1203 TI.getTypeWidth(TI.getIntMaxType()) &&
1204 "uintmax_t and intmax_t have different widths?");
1205
1206 if (LangOpts.FixedPoint) {
1207 // Each unsigned type has the same width as their signed type.
1208 DefineFixedPointMacros(TI, Builder, "SFRACT", "HR", TI.getShortFractWidth(),
1209 TI.getShortFractScale(), /*Signed=*/true);
1210 DefineFixedPointMacros(TI, Builder, "USFRACT", "UHR",
1211 TI.getShortFractWidth(),
1212 TI.getUnsignedShortFractScale(), /*Signed=*/false);
1213 DefineFixedPointMacros(TI, Builder, "FRACT", "R", TI.getFractWidth(),
1214 TI.getFractScale(), /*Signed=*/true);
1215 DefineFixedPointMacros(TI, Builder, "UFRACT", "UR", TI.getFractWidth(),
1216 TI.getUnsignedFractScale(), /*Signed=*/false);
1217 DefineFixedPointMacros(TI, Builder, "LFRACT", "LR", TI.getLongFractWidth(),
1218 TI.getLongFractScale(), /*Signed=*/true);
1219 DefineFixedPointMacros(TI, Builder, "ULFRACT", "ULR",
1220 TI.getLongFractWidth(),
1221 TI.getUnsignedLongFractScale(), /*Signed=*/false);
1222 DefineFixedPointMacros(TI, Builder, "SACCUM", "HK", TI.getShortAccumWidth(),
1223 TI.getShortAccumScale(), /*Signed=*/true);
1224 DefineFixedPointMacros(TI, Builder, "USACCUM", "UHK",
1225 TI.getShortAccumWidth(),
1226 TI.getUnsignedShortAccumScale(), /*Signed=*/false);
1227 DefineFixedPointMacros(TI, Builder, "ACCUM", "K", TI.getAccumWidth(),
1228 TI.getAccumScale(), /*Signed=*/true);
1229 DefineFixedPointMacros(TI, Builder, "UACCUM", "UK", TI.getAccumWidth(),
1230 TI.getUnsignedAccumScale(), /*Signed=*/false);
1231 DefineFixedPointMacros(TI, Builder, "LACCUM", "LK", TI.getLongAccumWidth(),
1232 TI.getLongAccumScale(), /*Signed=*/true);
1233 DefineFixedPointMacros(TI, Builder, "ULACCUM", "ULK",
1234 TI.getLongAccumWidth(),
1235 TI.getUnsignedLongAccumScale(), /*Signed=*/false);
1236
1237 Builder.defineMacro("__SACCUM_IBIT__", Twine(TI.getShortAccumIBits()));
1238 Builder.defineMacro("__USACCUM_IBIT__",
1239 Twine(TI.getUnsignedShortAccumIBits()));
1240 Builder.defineMacro("__ACCUM_IBIT__", Twine(TI.getAccumIBits()));
1241 Builder.defineMacro("__UACCUM_IBIT__", Twine(TI.getUnsignedAccumIBits()));
1242 Builder.defineMacro("__LACCUM_IBIT__", Twine(TI.getLongAccumIBits()));
1243 Builder.defineMacro("__ULACCUM_IBIT__",
1244 Twine(TI.getUnsignedLongAccumIBits()));
1245 }
1246
1247 if (TI.hasFloat16Type())
1248 DefineFloatMacros(Builder, "FLT16", &TI.getHalfFormat(), "F16");
1249 DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
1250 DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
1251 DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
1252
1253 // Define a __POINTER_WIDTH__ macro for stdint.h.
1254 Builder.defineMacro("__POINTER_WIDTH__",
1255 Twine((int)TI.getPointerWidth(LangAS::Default)));
1256
1257 // Define __BIGGEST_ALIGNMENT__ to be compatible with gcc.
1258 Builder.defineMacro("__BIGGEST_ALIGNMENT__",
1259 Twine(TI.getSuitableAlign() / TI.getCharWidth()) );
1260
1261 if (!LangOpts.CharIsSigned)
1262 Builder.defineMacro("__CHAR_UNSIGNED__");
1263
1265 Builder.defineMacro("__WCHAR_UNSIGNED__");
1266
1268 Builder.defineMacro("__WINT_UNSIGNED__");
1269
1270 // Define exact-width integer types for stdint.h
1271 DefineExactWidthIntType(LangOpts, TargetInfo::SignedChar, TI, Builder);
1272
1273 if (TI.getShortWidth() > TI.getCharWidth())
1274 DefineExactWidthIntType(LangOpts, TargetInfo::SignedShort, TI, Builder);
1275
1276 if (TI.getIntWidth() > TI.getShortWidth())
1277 DefineExactWidthIntType(LangOpts, TargetInfo::SignedInt, TI, Builder);
1278
1279 if (TI.getLongWidth() > TI.getIntWidth())
1280 DefineExactWidthIntType(LangOpts, TargetInfo::SignedLong, TI, Builder);
1281
1282 if (TI.getLongLongWidth() > TI.getLongWidth())
1283 DefineExactWidthIntType(LangOpts, TargetInfo::SignedLongLong, TI, Builder);
1284
1285 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedChar, TI, Builder);
1286 DefineExactWidthIntTypeSize(TargetInfo::UnsignedChar, TI, Builder);
1287 DefineExactWidthIntTypeSize(TargetInfo::SignedChar, TI, Builder);
1288
1289 if (TI.getShortWidth() > TI.getCharWidth()) {
1290 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedShort, TI, Builder);
1291 DefineExactWidthIntTypeSize(TargetInfo::UnsignedShort, TI, Builder);
1292 DefineExactWidthIntTypeSize(TargetInfo::SignedShort, TI, Builder);
1293 }
1294
1295 if (TI.getIntWidth() > TI.getShortWidth()) {
1296 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedInt, TI, Builder);
1297 DefineExactWidthIntTypeSize(TargetInfo::UnsignedInt, TI, Builder);
1298 DefineExactWidthIntTypeSize(TargetInfo::SignedInt, TI, Builder);
1299 }
1300
1301 if (TI.getLongWidth() > TI.getIntWidth()) {
1302 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedLong, TI, Builder);
1303 DefineExactWidthIntTypeSize(TargetInfo::UnsignedLong, TI, Builder);
1304 DefineExactWidthIntTypeSize(TargetInfo::SignedLong, TI, Builder);
1305 }
1306
1307 if (TI.getLongLongWidth() > TI.getLongWidth()) {
1308 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedLongLong, TI,
1309 Builder);
1310 DefineExactWidthIntTypeSize(TargetInfo::UnsignedLongLong, TI, Builder);
1311 DefineExactWidthIntTypeSize(TargetInfo::SignedLongLong, TI, Builder);
1312 }
1313
1314 DefineLeastWidthIntType(LangOpts, 8, true, TI, Builder);
1315 DefineLeastWidthIntType(LangOpts, 8, false, TI, Builder);
1316 DefineLeastWidthIntType(LangOpts, 16, true, TI, Builder);
1317 DefineLeastWidthIntType(LangOpts, 16, false, TI, Builder);
1318 DefineLeastWidthIntType(LangOpts, 32, true, TI, Builder);
1319 DefineLeastWidthIntType(LangOpts, 32, false, TI, Builder);
1320 DefineLeastWidthIntType(LangOpts, 64, true, TI, Builder);
1321 DefineLeastWidthIntType(LangOpts, 64, false, TI, Builder);
1322
1323 DefineFastIntType(LangOpts, 8, true, TI, Builder);
1324 DefineFastIntType(LangOpts, 8, false, TI, Builder);
1325 DefineFastIntType(LangOpts, 16, true, TI, Builder);
1326 DefineFastIntType(LangOpts, 16, false, TI, Builder);
1327 DefineFastIntType(LangOpts, 32, true, TI, Builder);
1328 DefineFastIntType(LangOpts, 32, false, TI, Builder);
1329 DefineFastIntType(LangOpts, 64, true, TI, Builder);
1330 DefineFastIntType(LangOpts, 64, false, TI, Builder);
1331
1332 Builder.defineMacro("__USER_LABEL_PREFIX__", TI.getUserLabelPrefix());
1333
1334 if (!LangOpts.MathErrno)
1335 Builder.defineMacro("__NO_MATH_ERRNO__");
1336
1337 if (LangOpts.FastMath || (LangOpts.NoHonorInfs && LangOpts.NoHonorNaNs))
1338 Builder.defineMacro("__FINITE_MATH_ONLY__", "1");
1339 else
1340 Builder.defineMacro("__FINITE_MATH_ONLY__", "0");
1341
1342 if (LangOpts.GNUCVersion) {
1343 if (LangOpts.GNUInline || LangOpts.CPlusPlus)
1344 Builder.defineMacro("__GNUC_GNU_INLINE__");
1345 else
1346 Builder.defineMacro("__GNUC_STDC_INLINE__");
1347
1348 // The value written by __atomic_test_and_set.
1349 // FIXME: This is target-dependent.
1350 Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
1351 }
1352
1353 // GCC defines these macros in both C and C++ modes despite them being needed
1354 // mostly for STL implementations in C++.
1355 auto [Destructive, Constructive] = TI.hardwareInterferenceSizes();
1356 Builder.defineMacro("__GCC_DESTRUCTIVE_SIZE", Twine(Destructive));
1357 Builder.defineMacro("__GCC_CONSTRUCTIVE_SIZE", Twine(Constructive));
1358 // We need to use push_macro to allow users to redefine these macros from the
1359 // command line with -D and not issue a -Wmacro-redefined warning.
1360 Builder.append("#pragma push_macro(\"__GCC_DESTRUCTIVE_SIZE\")");
1361 Builder.append("#pragma push_macro(\"__GCC_CONSTRUCTIVE_SIZE\")");
1362
1363 auto addLockFreeMacros = [&](const llvm::Twine &Prefix) {
1364 // Used by libc++ and libstdc++ to implement ATOMIC_<foo>_LOCK_FREE.
1365#define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \
1366 Builder.defineMacro(Prefix + #TYPE "_LOCK_FREE", \
1367 getLockFreeValue(TI.get##Type##Width(), TI));
1369 DEFINE_LOCK_FREE_MACRO(CHAR, Char);
1370 // char8_t has the same representation / width as unsigned
1371 // char in C++ and is a typedef for unsigned char in C23
1372 if (LangOpts.Char8 || LangOpts.C23)
1373 DEFINE_LOCK_FREE_MACRO(CHAR8_T, Char);
1374 DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16);
1375 DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32);
1376 DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar);
1378 DEFINE_LOCK_FREE_MACRO(INT, Int);
1381 Builder.defineMacro(
1382 Prefix + "POINTER_LOCK_FREE",
1383 getLockFreeValue(TI.getPointerWidth(LangAS::Default), TI));
1384#undef DEFINE_LOCK_FREE_MACRO
1385 };
1386 addLockFreeMacros("__CLANG_ATOMIC_");
1387 if (LangOpts.GNUCVersion)
1388 addLockFreeMacros("__GCC_ATOMIC_");
1389
1390 if (LangOpts.NoInlineDefine)
1391 Builder.defineMacro("__NO_INLINE__");
1392
1393 if (unsigned PICLevel = LangOpts.PICLevel) {
1394 Builder.defineMacro("__PIC__", Twine(PICLevel));
1395 Builder.defineMacro("__pic__", Twine(PICLevel));
1396 if (LangOpts.PIE) {
1397 Builder.defineMacro("__PIE__", Twine(PICLevel));
1398 Builder.defineMacro("__pie__", Twine(PICLevel));
1399 }
1400 }
1401
1402 // Macros to control C99 numerics and <float.h>
1403 Builder.defineMacro("__FLT_RADIX__", "2");
1404 Builder.defineMacro("__DECIMAL_DIG__", "__LDBL_DECIMAL_DIG__");
1405
1406 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
1407 Builder.defineMacro("__SSP__");
1408 else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
1409 Builder.defineMacro("__SSP_STRONG__", "2");
1410 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
1411 Builder.defineMacro("__SSP_ALL__", "3");
1412
1413 if (PPOpts.SetUpStaticAnalyzer)
1414 Builder.defineMacro("__clang_analyzer__");
1415
1416 if (LangOpts.FastRelaxedMath)
1417 Builder.defineMacro("__FAST_RELAXED_MATH__");
1418
1419 if (FEOpts.ProgramAction == frontend::RewriteObjC ||
1420 LangOpts.getGC() != LangOptions::NonGC) {
1421 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
1422 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
1423 Builder.defineMacro("__autoreleasing", "");
1424 Builder.defineMacro("__unsafe_unretained", "");
1425 } else if (LangOpts.ObjC) {
1426 Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))");
1427 Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))");
1428 Builder.defineMacro("__autoreleasing",
1429 "__attribute__((objc_ownership(autoreleasing)))");
1430 Builder.defineMacro("__unsafe_unretained",
1431 "__attribute__((objc_ownership(none)))");
1432 }
1433
1434 // On Darwin, there are __double_underscored variants of the type
1435 // nullability qualifiers.
1436 if (TI.getTriple().isOSDarwin()) {
1437 Builder.defineMacro("__nonnull", "_Nonnull");
1438 Builder.defineMacro("__null_unspecified", "_Null_unspecified");
1439 Builder.defineMacro("__nullable", "_Nullable");
1440 }
1441
1442 // Add a macro to differentiate between regular iOS/tvOS/watchOS targets and
1443 // the corresponding simulator targets.
1444 if (TI.getTriple().isOSDarwin() && TI.getTriple().isSimulatorEnvironment())
1445 Builder.defineMacro("__APPLE_EMBEDDED_SIMULATOR__", "1");
1446
1447 // OpenMP definition
1448 // OpenMP 2.2:
1449 // In implementations that support a preprocessor, the _OPENMP
1450 // macro name is defined to have the decimal value yyyymm where
1451 // yyyy and mm are the year and the month designations of the
1452 // version of the OpenMP API that the implementation support.
1453 if (!LangOpts.OpenMPSimd) {
1454 switch (LangOpts.OpenMP) {
1455 case 0:
1456 break;
1457 case 31:
1458 Builder.defineMacro("_OPENMP", "201107");
1459 break;
1460 case 40:
1461 Builder.defineMacro("_OPENMP", "201307");
1462 break;
1463 case 45:
1464 Builder.defineMacro("_OPENMP", "201511");
1465 break;
1466 case 50:
1467 Builder.defineMacro("_OPENMP", "201811");
1468 break;
1469 case 52:
1470 Builder.defineMacro("_OPENMP", "202111");
1471 break;
1472 default: // case 51:
1473 // Default version is OpenMP 5.1
1474 Builder.defineMacro("_OPENMP", "202011");
1475 break;
1476 }
1477 }
1478
1479 // CUDA device path compilaton
1480 if (LangOpts.CUDAIsDevice && !LangOpts.HIP) {
1481 // The CUDA_ARCH value is set for the GPU target specified in the NVPTX
1482 // backend's target defines.
1483 Builder.defineMacro("__CUDA_ARCH__");
1484 }
1485
1486 // We need to communicate this to our CUDA/HIP header wrapper, which in turn
1487 // informs the proper CUDA/HIP headers of this choice.
1488 if (LangOpts.GPUDeviceApproxTranscendentals)
1489 Builder.defineMacro("__CLANG_GPU_APPROX_TRANSCENDENTALS__");
1490
1491 // Define a macro indicating that the source file is being compiled with a
1492 // SYCL device compiler which doesn't produce host binary.
1493 if (LangOpts.SYCLIsDevice) {
1494 Builder.defineMacro("__SYCL_DEVICE_ONLY__", "1");
1495 }
1496
1497 // OpenCL definitions.
1498 if (LangOpts.OpenCL) {
1499 InitializeOpenCLFeatureTestMacros(TI, LangOpts, Builder);
1500
1501 if (TI.getTriple().isSPIR() || TI.getTriple().isSPIRV())
1502 Builder.defineMacro("__IMAGE_SUPPORT__");
1503 }
1504
1505 if (TI.hasInt128Type() && LangOpts.CPlusPlus && LangOpts.GNUMode) {
1506 // For each extended integer type, g++ defines a macro mapping the
1507 // index of the type (0 in this case) in some list of extended types
1508 // to the type.
1509 Builder.defineMacro("__GLIBCXX_TYPE_INT_N_0", "__int128");
1510 Builder.defineMacro("__GLIBCXX_BITSIZE_INT_N_0", "128");
1511 }
1512
1513 // ELF targets define __ELF__
1514 if (TI.getTriple().isOSBinFormatELF())
1515 Builder.defineMacro("__ELF__");
1516
1517 // Target OS macro definitions.
1518 if (PPOpts.DefineTargetOSMacros) {
1519 const llvm::Triple &Triple = TI.getTriple();
1520#define TARGET_OS(Name, Predicate) \
1521 Builder.defineMacro(#Name, (Predicate) ? "1" : "0");
1522#include "clang/Basic/TargetOSMacros.def"
1523#undef TARGET_OS
1524 }
1525
1526 // Get other target #defines.
1527 TI.getTargetDefines(LangOpts, Builder);
1528}
1529
1530static void InitializePGOProfileMacros(const CodeGenOptions &CodeGenOpts,
1531 MacroBuilder &Builder) {
1532 if (CodeGenOpts.hasProfileInstr())
1533 Builder.defineMacro("__LLVM_INSTR_PROFILE_GENERATE");
1534
1535 if (CodeGenOpts.hasProfileIRUse() || CodeGenOpts.hasProfileClangUse())
1536 Builder.defineMacro("__LLVM_INSTR_PROFILE_USE");
1537}
1538
1539/// InitializePreprocessor - Initialize the preprocessor getting it and the
1540/// environment ready to process a single file.
1542 const PreprocessorOptions &InitOpts,
1543 const PCHContainerReader &PCHContainerRdr,
1544 const FrontendOptions &FEOpts,
1545 const CodeGenOptions &CodeGenOpts) {
1546 const LangOptions &LangOpts = PP.getLangOpts();
1547 std::string PredefineBuffer;
1548 PredefineBuffer.reserve(4080);
1549 llvm::raw_string_ostream Predefines(PredefineBuffer);
1550 MacroBuilder Builder(Predefines);
1551
1552 // Emit line markers for various builtin sections of the file. The 3 here
1553 // marks <built-in> as being a system header, which suppresses warnings when
1554 // the same macro is defined multiple times.
1555 Builder.append("# 1 \"<built-in>\" 3");
1556
1557 // Install things like __POWERPC__, __GNUC__, etc into the macro table.
1558 if (InitOpts.UsePredefines) {
1559 // FIXME: This will create multiple definitions for most of the predefined
1560 // macros. This is not the right way to handle this.
1561 if ((LangOpts.CUDA || LangOpts.OpenMPIsTargetDevice ||
1562 LangOpts.SYCLIsDevice) &&
1563 PP.getAuxTargetInfo())
1564 InitializePredefinedMacros(*PP.getAuxTargetInfo(), LangOpts, FEOpts,
1565 PP.getPreprocessorOpts(), Builder);
1566
1567 InitializePredefinedMacros(PP.getTargetInfo(), LangOpts, FEOpts,
1568 PP.getPreprocessorOpts(), Builder);
1569
1570 // Install definitions to make Objective-C++ ARC work well with various
1571 // C++ Standard Library implementations.
1572 if (LangOpts.ObjC && LangOpts.CPlusPlus &&
1573 (LangOpts.ObjCAutoRefCount || LangOpts.ObjCWeak)) {
1574 switch (InitOpts.ObjCXXARCStandardLibrary) {
1575 case ARCXX_nolib:
1576 case ARCXX_libcxx:
1577 break;
1578
1579 case ARCXX_libstdcxx:
1580 AddObjCXXARCLibstdcxxDefines(LangOpts, Builder);
1581 break;
1582 }
1583 }
1584 }
1585
1586 // Even with predefines off, some macros are still predefined.
1587 // These should all be defined in the preprocessor according to the
1588 // current language configuration.
1590 FEOpts, Builder);
1591
1592 // The PGO instrumentation profile macros are driven by options
1593 // -fprofile[-instr]-generate/-fcs-profile-generate/-fprofile[-instr]-use,
1594 // hence they are not guarded by InitOpts.UsePredefines.
1595 InitializePGOProfileMacros(CodeGenOpts, Builder);
1596
1597 // Add on the predefines from the driver. Wrap in a #line directive to report
1598 // that they come from the command line.
1599 Builder.append("# 1 \"<command line>\" 1");
1600
1601 // Process #define's and #undef's in the order they are given.
1602 for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
1603 if (InitOpts.Macros[i].second) // isUndef
1604 Builder.undefineMacro(InitOpts.Macros[i].first);
1605 else
1606 DefineBuiltinMacro(Builder, InitOpts.Macros[i].first,
1607 PP.getDiagnostics());
1608 }
1609
1610 // Exit the command line and go back to <built-in> (2 is LC_LEAVE).
1611 Builder.append("# 1 \"<built-in>\" 2");
1612
1613 // If -imacros are specified, include them now. These are processed before
1614 // any -include directives.
1615 for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
1616 AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i]);
1617
1618 // Process -include-pch/-include-pth directives.
1619 if (!InitOpts.ImplicitPCHInclude.empty())
1620 AddImplicitIncludePCH(Builder, PP, PCHContainerRdr,
1621 InitOpts.ImplicitPCHInclude);
1622
1623 // Process -include directives.
1624 for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {
1625 const std::string &Path = InitOpts.Includes[i];
1626 AddImplicitInclude(Builder, Path);
1627 }
1628
1629 // Instruct the preprocessor to skip the preamble.
1631 InitOpts.PrecompiledPreambleBytes.second);
1632
1633 // Copy PredefinedBuffer into the Preprocessor.
1634 PP.setPredefines(std::move(PredefineBuffer));
1635}
IndirectLocalPath & Path
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 DefineFmt(const LangOptions &LangOpts, const Twine &Prefix, TargetInfo::IntType Ty, 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 DefineExactWidthIntTypeSize(TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
void DefineFixedPointMacros(const TargetInfo &TI, MacroBuilder &Builder, llvm::StringRef TypeName, llvm::StringRef Suffix, unsigned Width, unsigned Scale, bool Signed)
static void InitializePGOProfileMacros(const CodeGenOptions &CodeGenOpts, 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 DefineExactWidthIntType(const LangOptions &LangOpts, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder)
llvm::SmallString< 32 > ConstructFixedPointLiteral(llvm::APFixedPoint Val, llvm::StringRef Suffix)
static void DefineLeastWidthIntType(const LangOptions &LangOpts, unsigned TypeWidth, bool IsSigned, const TargetInfo &TI, MacroBuilder &Builder)
#define TOSTR(X)
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(const LangOptions &LangOpts, 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:1942
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
bool hasProfileInstr() const
Check if any form of instrumentation is on.
bool hasProfileIRUse() const
Check if IR level profile use is on.
bool hasProfileClangUse() const
Check if Clang profile use is on.
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:231
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1493
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:500
bool hasWasmExceptions() const
Definition: LangOptions.h:768
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:535
bool hasSjLjExceptions() const
Definition: LangOptions.h:756
bool hasDWARFExceptions() const
Definition: LangOptions.h:764
bool hasSEHExceptions() const
Definition: LangOptions.h:760
std::string OpenACCMacroOverride
Definition: LangOptions.h:620
GPUDefaultStreamKind GPUDefaultStream
The default stream kind used for HIP kernel launching.
Definition: LangOptions.h:595
Kind getKind() const
Definition: ObjCRuntime.h:77
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:143
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...
bool DefineTargetOSMacros
Indicates whether to predefine target OS macros.
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:138
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:220
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' is g...
Definition: TargetInfo.h:752
unsigned getUnsignedLongFractScale() const
getUnsignedLongFractScale - Return the number of fractional bits in a 'unsigned long _Fract' type.
Definition: TargetInfo.h:659
unsigned getShortWidth() const
getShortWidth/Align - Return the size of 'signed short' and 'unsigned short' for this target,...
Definition: TargetInfo.h:514
unsigned getUnsignedAccumScale() const
getUnsignedAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned _Accum' ty...
Definition: TargetInfo.h:613
unsigned getUnsignedAccumIBits() const
Definition: TargetInfo.h:616
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1262
unsigned getAccumWidth() const
getAccumWidth/Align - Return the size of 'signed _Accum' and 'unsigned _Accum' for this target,...
Definition: TargetInfo.h:558
IntType getUIntPtrType() const
Definition: TargetInfo.h:404
IntType getInt64Type() const
Definition: TargetInfo.h:411
unsigned getUnsignedFractScale() const
getUnsignedFractScale - Return the number of fractional bits in a 'unsigned _Fract' type.
Definition: TargetInfo.h:653
virtual IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return the smallest integer type with at least the specified width.
Definition: TargetInfo.cpp:317
virtual bool hasFeatureEnabled(const llvm::StringMap< bool > &Features, StringRef Name) const
Check if target has a given feature enabled.
Definition: TargetInfo.h:1385
virtual size_t getMaxBitIntWidth() const
Definition: TargetInfo.h:682
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
Definition: TargetInfo.cpp:286
unsigned getLongAccumScale() const
getLongAccumScale/IBits - Return the number of fractional/integral bits in a 'signed long _Accum' typ...
Definition: TargetInfo.h:595
unsigned getLongFractScale() const
getLongFractScale - Return the number of fractional bits in a 'signed long _Fract' type.
Definition: TargetInfo.h:642
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:478
static bool isTypeSigned(IntType T)
Returns true if the type is signed; false otherwise.
Definition: TargetInfo.cpp:386
virtual std::pair< unsigned, unsigned > hardwareInterferenceSizes() const
The first value in the pair is the minimum offset between two objects to avoid false sharing (destruc...
Definition: TargetInfo.h:1850
bool useSignedCharForObjCBool() const
Check if the Objective-C built-in boolean type should be signed char.
Definition: TargetInfo.h:924
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:665
unsigned getAccumIBits() const
Definition: TargetInfo.h:591
IntType getSigAtomicType() const
Definition: TargetInfo.h:419
unsigned getAccumScale() const
getAccumScale/IBits - Return the number of fractional/integral bits in a 'signed _Accum' type.
Definition: TargetInfo.h:590
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
Definition: TargetInfo.h:706
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
Definition: TargetInfo.h:519
IntType getPtrDiffType(LangAS AddrSpace) const
Definition: TargetInfo.h:396
bool isLittleEndian() const
Definition: TargetInfo.h:1673
unsigned getShortAccumIBits() const
Definition: TargetInfo.h:584
unsigned getFloatWidth() const
getFloatWidth/Align/Format - Return the size/align/format of 'float'.
Definition: TargetInfo.h:777
unsigned getLongAccumIBits() const
Definition: TargetInfo.h:596
IntType getSizeType() const
Definition: TargetInfo.h:377
IntType getWIntType() const
Definition: TargetInfo.h:408
virtual void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const =0
===-— Other target property query methods -----------------------—===//
unsigned getLongAccumWidth() const
getLongAccumWidth/Align - Return the size of 'signed long _Accum' and 'unsigned long _Accum' for this...
Definition: TargetInfo.h:563
unsigned getShortAccumScale() const
getShortAccumScale/IBits - Return the number of fractional/integral bits in a 'signed short _Accum' t...
Definition: TargetInfo.h:583
const llvm::fltSemantics & getDoubleFormat() const
Definition: TargetInfo.h:789
static const char * getTypeName(IntType T)
Return the user string for the specified integer type enum.
Definition: TargetInfo.cpp:225
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
Definition: TargetInfo.h:529
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:850
IntType getIntPtrType() const
Definition: TargetInfo.h:403
IntType getInt16Type() const
Definition: TargetInfo.h:415
const llvm::fltSemantics & getHalfFormat() const
Definition: TargetInfo.h:774
llvm::StringMap< bool > & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1779
IntType getWCharType() const
Definition: TargetInfo.h:407
IntType getUInt16Type() const
Definition: TargetInfo.h:416
bool isBigEndian() const
Definition: TargetInfo.h:1672
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:912
IntType getChar16Type() const
Definition: TargetInfo.h:409
unsigned getUnsignedShortAccumIBits() const
Definition: TargetInfo.h:605
IntType getChar32Type() const
Definition: TargetInfo.h:410
IntType getUInt64Type() const
Definition: TargetInfo.h:412
unsigned getUnsignedLongAccumScale() const
getUnsignedLongAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned long _...
Definition: TargetInfo.h:623
unsigned getUnsignedLongAccumIBits() const
Definition: TargetInfo.h:626
unsigned getUnsignedShortFractScale() const
getUnsignedShortFractScale - Return the number of fractional bits in a 'unsigned short _Fract' type.
Definition: TargetInfo.h:646
const llvm::fltSemantics & getLongDoubleFormat() const
Definition: TargetInfo.h:795
const llvm::fltSemantics & getFloatFormat() const
Definition: TargetInfo.h:779
const char * getTypeConstantSuffix(IntType T) const
Return the constant suffix for the specified integer type enum.
Definition: TargetInfo.cpp:243
unsigned getDoubleWidth() const
getDoubleWidth/Align/Format - Return the size/align/format of 'double'.
Definition: TargetInfo.h:787
unsigned getShortAccumWidth() const
getShortAccumWidth/Align - Return the size of 'signed short _Accum' and 'unsigned short _Accum' for t...
Definition: TargetInfo.h:553
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:733
unsigned getCharWidth() const
Definition: TargetInfo.h:509
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
Definition: TargetInfo.h:524
unsigned getLongFractWidth() const
getLongFractWidth/Align - Return the size of 'signed long _Fract' and 'unsigned long _Fract' for this...
Definition: TargetInfo.h:578
IntType getIntMaxType() const
Definition: TargetInfo.h:392
unsigned getFractScale() const
getFractScale - Return the number of fractional bits in a 'signed _Fract' type.
Definition: TargetInfo.h:638
unsigned getFractWidth() const
getFractWidth/Align - Return the size of 'signed _Fract' and 'unsigned _Fract' for this target,...
Definition: TargetInfo.h:573
unsigned getShortFractScale() const
getShortFractScale - Return the number of fractional bits in a 'signed short _Fract' type.
Definition: TargetInfo.h:634
unsigned getShortFractWidth() const
getShortFractWidth/Align - Return the size of 'signed short _Fract' and 'unsigned short _Fract' for t...
Definition: TargetInfo.h:568
virtual bool hasHIPImageSupport() const
Whether to support HIP image/texture API's.
Definition: TargetInfo.h:1843
static const char * getTypeFormatModifier(IntType T)
Return the printf format modifier for the specified integer type enum.
Definition: TargetInfo.cpp:268
unsigned getUnsignedShortAccumScale() const
getUnsignedShortAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned short...
Definition: TargetInfo.h:602
bool doUnsignedFixedPointTypesHavePadding() const
In the event this target uses the same number of fractional bits for its unsigned types as it does wi...
Definition: TargetInfo.h:443
IntType getUIntMaxType() const
Definition: TargetInfo.h:393
unsigned getLongDoubleWidth() const
getLongDoubleWidth/Align/Format - Return the size/align/format of 'long double'.
Definition: TargetInfo.h:793
Defines the clang::TargetInfo interface.
@ RewriteObjC
ObjC->C Rewriter.
The JSON file list parser is used to communicate input to InstallAPI.
void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts, const CodeGenOptions &CodeGenOpts)
InitializePreprocessor - Initialize the preprocessor getting it and the environment ready to process ...
@ 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:108
const FunctionProtoType * T
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:68
std::string getClangFullCPPVersion()
Retrieves a string representing the complete clang version suitable for use in the CPP VERSION macro,...
Definition: Version.cpp:113
IntType
===-— Target Data Type Query Methods ----------------------------—===//
Definition: TargetInfo.h:144