clang 22.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.ends_with('\\');
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 Builder.defineMacro("__HLSL_202x",
398 Twine((unsigned)LangOptions::HLSLLangStd::HLSL_202x));
399 Builder.defineMacro("__HLSL_202y",
400 Twine((unsigned)LangOptions::HLSLLangStd::HLSL_202y));
401
402 if (LangOpts.NativeHalfType)
403 Builder.defineMacro("__HLSL_ENABLE_16_BIT", "1");
404
405 // Shader target information
406 // "enums" for shader stages
407 Builder.defineMacro("__SHADER_STAGE_VERTEX",
408 Twine((uint32_t)ShaderStage::Vertex));
409 Builder.defineMacro("__SHADER_STAGE_PIXEL",
410 Twine((uint32_t)ShaderStage::Pixel));
411 Builder.defineMacro("__SHADER_STAGE_GEOMETRY",
412 Twine((uint32_t)ShaderStage::Geometry));
413 Builder.defineMacro("__SHADER_STAGE_HULL",
414 Twine((uint32_t)ShaderStage::Hull));
415 Builder.defineMacro("__SHADER_STAGE_DOMAIN",
416 Twine((uint32_t)ShaderStage::Domain));
417 Builder.defineMacro("__SHADER_STAGE_COMPUTE",
418 Twine((uint32_t)ShaderStage::Compute));
419 Builder.defineMacro("__SHADER_STAGE_AMPLIFICATION",
420 Twine((uint32_t)ShaderStage::Amplification));
421 Builder.defineMacro("__SHADER_STAGE_MESH",
422 Twine((uint32_t)ShaderStage::Mesh));
423 Builder.defineMacro("__SHADER_STAGE_LIBRARY",
424 Twine((uint32_t)ShaderStage::Library));
425 // The current shader stage itself
426 uint32_t StageInteger = static_cast<uint32_t>(
427 hlsl::getStageFromEnvironment(TI.getTriple().getEnvironment()));
428
429 Builder.defineMacro("__SHADER_TARGET_STAGE", Twine(StageInteger));
430 // Add target versions
431 if (TI.getTriple().getOS() == llvm::Triple::ShaderModel) {
432 VersionTuple Version = TI.getTriple().getOSVersion();
433 Builder.defineMacro("__SHADER_TARGET_MAJOR", Twine(Version.getMajor()));
434 unsigned Minor = Version.getMinor().value_or(0);
435 Builder.defineMacro("__SHADER_TARGET_MINOR", Twine(Minor));
436 }
437 return;
438 }
439 // C++ [cpp.predefined]p1:
440 // The following macro names shall be defined by the implementation:
441
442 // -- __STDC__
443 // [C++] Whether __STDC__ is predefined and if so, what its value is,
444 // are implementation-defined.
445 // (Removed in C++20.)
446 if ((!LangOpts.MSVCCompat || LangOpts.MSVCEnableStdcMacro) &&
447 !LangOpts.TraditionalCPP)
448 Builder.defineMacro("__STDC__");
449 // -- __STDC_HOSTED__
450 // The integer literal 1 if the implementation is a hosted
451 // implementation or the integer literal 0 if it is not.
452 if (LangOpts.Freestanding)
453 Builder.defineMacro("__STDC_HOSTED__", "0");
454 else
455 Builder.defineMacro("__STDC_HOSTED__");
456
457 // -- __STDC_VERSION__
458 // [C++] Whether __STDC_VERSION__ is predefined and if so, what its
459 // value is, are implementation-defined.
460 // (Removed in C++20.)
461 if (!LangOpts.CPlusPlus) {
462 if (std::optional<uint32_t> Lang = LangOpts.getCLangStd())
463 Builder.defineMacro("__STDC_VERSION__", Twine(*Lang) + "L");
464 } else {
465 // -- __cplusplus
466 Builder.defineMacro("__cplusplus",
467 Twine(*LangOpts.getCPlusPlusLangStd()) + "L");
468
469 // -- __STDCPP_DEFAULT_NEW_ALIGNMENT__
470 // [C++17] An integer literal of type std::size_t whose value is the
471 // alignment guaranteed by a call to operator new(std::size_t)
472 //
473 // We provide this in all language modes, since it seems generally useful.
474 Builder.defineMacro("__STDCPP_DEFAULT_NEW_ALIGNMENT__",
475 Twine(TI.getNewAlign() / TI.getCharWidth()) +
477
478 // -- __STDCPP_­THREADS__
479 // Defined, and has the value integer literal 1, if and only if a
480 // program can have more than one thread of execution.
481 if (LangOpts.getThreadModel() == LangOptions::ThreadModelKind::POSIX)
482 Builder.defineMacro("__STDCPP_THREADS__", "1");
483 }
484
485 // In C11 these are environment macros. In C++11 they are only defined
486 // as part of <cuchar>. To prevent breakage when mixing C and C++
487 // code, define these macros unconditionally. We can define them
488 // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit
489 // and 32-bit character literals.
490 Builder.defineMacro("__STDC_UTF_16__", "1");
491 Builder.defineMacro("__STDC_UTF_32__", "1");
492
493 // __has_embed definitions
494 Builder.defineMacro("__STDC_EMBED_NOT_FOUND__",
495 llvm::itostr(static_cast<int>(EmbedResult::NotFound)));
496 Builder.defineMacro("__STDC_EMBED_FOUND__",
497 llvm::itostr(static_cast<int>(EmbedResult::Found)));
498 Builder.defineMacro("__STDC_EMBED_EMPTY__",
499 llvm::itostr(static_cast<int>(EmbedResult::Empty)));
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", "202012L");
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 ==
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 Builder.defineMacro("__HIP_MEMORY_SCOPE_CLUSTER", "6");
589 if (LangOpts.HIPStdPar) {
590 Builder.defineMacro("__HIPSTDPAR__");
591 if (LangOpts.HIPStdParInterposeAlloc) {
592 Builder.defineMacro("__HIPSTDPAR_INTERPOSE_ALLOC__");
593 Builder.defineMacro("__HIPSTDPAR_INTERPOSE_ALLOC_V1__");
594 }
595 }
596 if (LangOpts.CUDAIsDevice) {
597 Builder.defineMacro("__HIP_DEVICE_COMPILE__");
598 if (!TI.hasHIPImageSupport()) {
599 Builder.defineMacro("__HIP_NO_IMAGE_SUPPORT__", "1");
600 // Deprecated.
601 Builder.defineMacro("__HIP_NO_IMAGE_SUPPORT", "1");
602 }
603 }
604 if (LangOpts.GPUDefaultStream ==
606 Builder.defineMacro("__HIP_API_PER_THREAD_DEFAULT_STREAM__");
607 // Deprecated.
608 Builder.defineMacro("HIP_API_PER_THREAD_DEFAULT_STREAM");
609 }
610 }
611
612 if (LangOpts.OpenACC)
613 Builder.defineMacro("_OPENACC", "202506");
614}
615
616/// Initialize the predefined C++ language feature test macros defined in
617/// ISO/IEC JTC1/SC22/WG21 (C++) SD-6: "SG10 Feature Test Recommendations".
619 MacroBuilder &Builder) {
620 // C++98 features.
621 if (LangOpts.RTTI)
622 Builder.defineMacro("__cpp_rtti", "199711L");
623 if (LangOpts.CXXExceptions)
624 Builder.defineMacro("__cpp_exceptions", "199711L");
625
626 // C++11 features.
627 if (LangOpts.CPlusPlus11) {
628 Builder.defineMacro("__cpp_unicode_characters", "200704L");
629 Builder.defineMacro("__cpp_raw_strings", "200710L");
630 Builder.defineMacro("__cpp_unicode_literals", "200710L");
631 Builder.defineMacro("__cpp_user_defined_literals", "200809L");
632 Builder.defineMacro("__cpp_lambdas", "200907L");
633 Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus26 ? "202406L"
634 : LangOpts.CPlusPlus23 ? "202211L"
635 : LangOpts.CPlusPlus20 ? "202002L"
636 : LangOpts.CPlusPlus17 ? "201603L"
637 : LangOpts.CPlusPlus14 ? "201304L"
638 : "200704");
639 Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L");
640 Builder.defineMacro("__cpp_range_based_for",
641 LangOpts.CPlusPlus23 ? "202211L"
642 : LangOpts.CPlusPlus17 ? "201603L"
643 : "200907");
644 // C++17 / C++26 static_assert supported as an extension in earlier language
645 // modes, so we use the C++26 value.
646 Builder.defineMacro("__cpp_static_assert", "202306L");
647 Builder.defineMacro("__cpp_decltype", "200707L");
648 Builder.defineMacro("__cpp_attributes", "200809L");
649 Builder.defineMacro("__cpp_rvalue_references", "200610L");
650 Builder.defineMacro("__cpp_variadic_templates", "200704L");
651 Builder.defineMacro("__cpp_initializer_lists", "200806L");
652 Builder.defineMacro("__cpp_delegating_constructors", "200604L");
653 Builder.defineMacro("__cpp_nsdmi", "200809L");
654 Builder.defineMacro("__cpp_inheriting_constructors", "201511L");
655 Builder.defineMacro("__cpp_ref_qualifiers", "200710L");
656 Builder.defineMacro("__cpp_alias_templates", "200704L");
657 }
658 if (LangOpts.ThreadsafeStatics)
659 Builder.defineMacro("__cpp_threadsafe_static_init", "200806L");
660
661 // C++14 features.
662 if (LangOpts.CPlusPlus14) {
663 Builder.defineMacro("__cpp_binary_literals", "201304L");
664 Builder.defineMacro("__cpp_digit_separators", "201309L");
665 Builder.defineMacro("__cpp_init_captures",
666 LangOpts.CPlusPlus20 ? "201803L" : "201304L");
667 Builder.defineMacro("__cpp_generic_lambdas",
668 LangOpts.CPlusPlus20 ? "201707L" : "201304L");
669 Builder.defineMacro("__cpp_decltype_auto", "201304L");
670 Builder.defineMacro("__cpp_return_type_deduction", "201304L");
671 Builder.defineMacro("__cpp_aggregate_nsdmi", "201304L");
672 Builder.defineMacro("__cpp_variable_templates", "201304L");
673 }
674 if (LangOpts.SizedDeallocation)
675 Builder.defineMacro("__cpp_sized_deallocation", "201309L");
676
677 // C++17 features.
678 if (LangOpts.CPlusPlus17) {
679 Builder.defineMacro("__cpp_hex_float", "201603L");
680 Builder.defineMacro("__cpp_inline_variables", "201606L");
681 Builder.defineMacro("__cpp_noexcept_function_type", "201510L");
682 Builder.defineMacro("__cpp_capture_star_this", "201603L");
683 Builder.defineMacro("__cpp_if_constexpr", "201606L");
684 Builder.defineMacro("__cpp_deduction_guides", "201703L"); // (not latest)
685 Builder.defineMacro("__cpp_template_auto", "201606L"); // (old name)
686 Builder.defineMacro("__cpp_namespace_attributes", "201411L");
687 Builder.defineMacro("__cpp_enumerator_attributes", "201411L");
688 Builder.defineMacro("__cpp_nested_namespace_definitions", "201411L");
689 Builder.defineMacro("__cpp_variadic_using", "201611L");
690 Builder.defineMacro("__cpp_aggregate_bases", "201603L");
691 Builder.defineMacro("__cpp_structured_bindings", "202411L");
692 Builder.defineMacro("__cpp_nontype_template_args",
693 "201411L"); // (not latest)
694 Builder.defineMacro("__cpp_fold_expressions", "201603L");
695 Builder.defineMacro("__cpp_guaranteed_copy_elision", "201606L");
696 Builder.defineMacro("__cpp_nontype_template_parameter_auto", "201606L");
697 }
698 if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)
699 Builder.defineMacro("__cpp_aligned_new", "201606L");
700
701 Builder.defineMacro("__cpp_template_template_args", "201611L");
702
703 // C++20 features.
704 if (LangOpts.CPlusPlus20) {
705 Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");
706
707 Builder.defineMacro("__cpp_concepts", "202002");
708 Builder.defineMacro("__cpp_conditional_explicit", "201806L");
709 Builder.defineMacro("__cpp_consteval", "202211L");
710 Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");
711 Builder.defineMacro("__cpp_constinit", "201907L");
712 Builder.defineMacro("__cpp_impl_coroutine", "201902L");
713 Builder.defineMacro("__cpp_designated_initializers", "201707L");
714 Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");
715 // Intentionally to set __cpp_modules to 1.
716 // See https://github.com/llvm/llvm-project/issues/71364 for details.
717 // Builder.defineMacro("__cpp_modules", "201907L");
718 Builder.defineMacro("__cpp_modules", "1");
719 Builder.defineMacro("__cpp_using_enum", "201907L");
720 }
721 // C++23 features.
722 if (LangOpts.CPlusPlus23) {
723 Builder.defineMacro("__cpp_implicit_move", "202207L");
724 Builder.defineMacro("__cpp_size_t_suffix", "202011L");
725 Builder.defineMacro("__cpp_if_consteval", "202106L");
726 Builder.defineMacro("__cpp_multidimensional_subscript", "202211L");
727 Builder.defineMacro("__cpp_auto_cast", "202110L");
728 Builder.defineMacro("__cpp_explicit_this_parameter", "202110L");
729 }
730
731 // We provide those C++23 features as extensions in earlier language modes, so
732 // we also define their feature test macros.
733 if (LangOpts.CPlusPlus11)
734 Builder.defineMacro("__cpp_static_call_operator", "202207L");
735 Builder.defineMacro("__cpp_named_character_escapes", "202207L");
736 Builder.defineMacro("__cpp_placeholder_variables", "202306L");
737
738 // C++26 features supported in earlier language modes.
739 Builder.defineMacro("__cpp_pack_indexing", "202311L");
740 Builder.defineMacro("__cpp_deleted_function", "202403L");
741 Builder.defineMacro("__cpp_variadic_friend", "202403L");
742 Builder.defineMacro("__cpp_trivial_relocatability", "202502L");
743
744 if (LangOpts.Char8)
745 Builder.defineMacro("__cpp_char8_t", "202207L");
746 Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
747}
748
749/// InitializeOpenCLFeatureTestMacros - Define OpenCL macros based on target
750/// settings and language version
752 const LangOptions &Opts,
753 MacroBuilder &Builder) {
754 const llvm::StringMap<bool> &OpenCLFeaturesMap = TI.getSupportedOpenCLOpts();
755 // FIXME: OpenCL options which affect language semantics/syntax
756 // should be moved into LangOptions.
757 auto defineOpenCLExtMacro = [&](llvm::StringRef Name, auto... OptArgs) {
758 // Check if extension is supported by target and is available in this
759 // OpenCL version
760 if (TI.hasFeatureEnabled(OpenCLFeaturesMap, Name) &&
762 Builder.defineMacro(Name);
763 };
764#define OPENCL_GENERIC_EXTENSION(Ext, ...) \
765 defineOpenCLExtMacro(#Ext, __VA_ARGS__);
766#include "clang/Basic/OpenCLExtensions.def"
767
768 // Assume compiling for FULL profile
769 Builder.defineMacro("__opencl_c_int64");
770}
771
773 llvm::StringRef Suffix) {
774 if (Val.isSigned() && Val == llvm::APFixedPoint::getMin(Val.getSemantics())) {
775 // When representing the min value of a signed fixed point type in source
776 // code, we cannot simply write `-<lowest value>`. For example, the min
777 // value of a `short _Fract` cannot be written as `-1.0hr`. This is because
778 // the parser will read this (and really any negative numerical literal) as
779 // a UnaryOperator that owns a FixedPointLiteral with a positive value
780 // rather than just a FixedPointLiteral with a negative value. Compiling
781 // `-1.0hr` results in an overflow to the maximal value of that fixed point
782 // type. The correct way to represent a signed min value is to instead split
783 // it into two halves, like `(-0.5hr-0.5hr)` which is what the standard
784 // defines SFRACT_MIN as.
785 llvm::SmallString<32> Literal;
786 Literal.push_back('(');
787 llvm::SmallString<32> HalfStr =
788 ConstructFixedPointLiteral(Val.shr(1), Suffix);
789 Literal += HalfStr;
790 Literal += HalfStr;
791 Literal.push_back(')');
792 return Literal;
793 }
794
795 llvm::SmallString<32> Str(Val.toString());
796 Str += Suffix;
797 return Str;
798}
799
801 llvm::StringRef TypeName, llvm::StringRef Suffix,
802 unsigned Width, unsigned Scale, bool Signed) {
803 // Saturation doesn't affect the size or scale of a fixed point type, so we
804 // don't need it here.
805 llvm::FixedPointSemantics FXSema(
806 Width, Scale, Signed, /*IsSaturated=*/false,
808 llvm::SmallString<32> MacroPrefix("__");
809 MacroPrefix += TypeName;
810 Builder.defineMacro(MacroPrefix + "_EPSILON__",
812 llvm::APFixedPoint::getEpsilon(FXSema), Suffix));
813 Builder.defineMacro(MacroPrefix + "_FBIT__", Twine(Scale));
814 Builder.defineMacro(
815 MacroPrefix + "_MAX__",
816 ConstructFixedPointLiteral(llvm::APFixedPoint::getMax(FXSema), Suffix));
817
818 // ISO/IEC TR 18037:2008 doesn't specify MIN macros for unsigned types since
819 // they're all just zero.
820 if (Signed)
821 Builder.defineMacro(
822 MacroPrefix + "_MIN__",
823 ConstructFixedPointLiteral(llvm::APFixedPoint::getMin(FXSema), Suffix));
824}
825
827 const LangOptions &LangOpts,
828 const FrontendOptions &FEOpts,
829 const PreprocessorOptions &PPOpts,
830 const CodeGenOptions &CGOpts,
831 MacroBuilder &Builder) {
832 // Compiler version introspection macros.
833 Builder.defineMacro("__llvm__"); // LLVM Backend
834 Builder.defineMacro("__clang__"); // Clang Frontend
835#define TOSTR2(X) #X
836#define TOSTR(X) TOSTR2(X)
837 Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR));
838 Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR));
839 Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL));
840#undef TOSTR
841#undef TOSTR2
842 Builder.defineMacro("__clang_version__",
843 "\"" CLANG_VERSION_STRING " "
845
846 if (LangOpts.GNUCVersion != 0) {
847 // Major, minor, patch, are given two decimal places each, so 4.2.1 becomes
848 // 40201.
849 unsigned GNUCMajor = LangOpts.GNUCVersion / 100 / 100;
850 unsigned GNUCMinor = LangOpts.GNUCVersion / 100 % 100;
851 unsigned GNUCPatch = LangOpts.GNUCVersion % 100;
852 Builder.defineMacro("__GNUC__", Twine(GNUCMajor));
853 Builder.defineMacro("__GNUC_MINOR__", Twine(GNUCMinor));
854 Builder.defineMacro("__GNUC_PATCHLEVEL__", Twine(GNUCPatch));
855 Builder.defineMacro("__GXX_ABI_VERSION", "1002");
856
857 if (LangOpts.CPlusPlus) {
858 Builder.defineMacro("__GNUG__", Twine(GNUCMajor));
859 Builder.defineMacro("__GXX_WEAK__");
860 }
861 }
862
863 // Define macros for the C11 / C++11 memory orderings
864 Builder.defineMacro("__ATOMIC_RELAXED", "0");
865 Builder.defineMacro("__ATOMIC_CONSUME", "1");
866 Builder.defineMacro("__ATOMIC_ACQUIRE", "2");
867 Builder.defineMacro("__ATOMIC_RELEASE", "3");
868 Builder.defineMacro("__ATOMIC_ACQ_REL", "4");
869 Builder.defineMacro("__ATOMIC_SEQ_CST", "5");
870
871 // Define macros for the clang atomic scopes.
872 Builder.defineMacro("__MEMORY_SCOPE_SYSTEM", "0");
873 Builder.defineMacro("__MEMORY_SCOPE_DEVICE", "1");
874 Builder.defineMacro("__MEMORY_SCOPE_WRKGRP", "2");
875 Builder.defineMacro("__MEMORY_SCOPE_WVFRNT", "3");
876 Builder.defineMacro("__MEMORY_SCOPE_SINGLE", "4");
877 Builder.defineMacro("__MEMORY_SCOPE_CLUSTR", "5");
878
879 // Define macros for the OpenCL memory scope.
880 // The values should match AtomicScopeOpenCLModel::ID enum.
881 static_assert(
882 static_cast<unsigned>(AtomicScopeOpenCLModel::WorkGroup) == 1 &&
883 static_cast<unsigned>(AtomicScopeOpenCLModel::Device) == 2 &&
884 static_cast<unsigned>(AtomicScopeOpenCLModel::AllSVMDevices) == 3 &&
885 static_cast<unsigned>(AtomicScopeOpenCLModel::SubGroup) == 4,
886 "Invalid OpenCL memory scope enum definition");
887 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_ITEM", "0");
888 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_GROUP", "1");
889 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_DEVICE", "2");
890 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES", "3");
891 Builder.defineMacro("__OPENCL_MEMORY_SCOPE_SUB_GROUP", "4");
892
893 // Define macros for floating-point data classes, used in __builtin_isfpclass.
894 Builder.defineMacro("__FPCLASS_SNAN", "0x0001");
895 Builder.defineMacro("__FPCLASS_QNAN", "0x0002");
896 Builder.defineMacro("__FPCLASS_NEGINF", "0x0004");
897 Builder.defineMacro("__FPCLASS_NEGNORMAL", "0x0008");
898 Builder.defineMacro("__FPCLASS_NEGSUBNORMAL", "0x0010");
899 Builder.defineMacro("__FPCLASS_NEGZERO", "0x0020");
900 Builder.defineMacro("__FPCLASS_POSZERO", "0x0040");
901 Builder.defineMacro("__FPCLASS_POSSUBNORMAL", "0x0080");
902 Builder.defineMacro("__FPCLASS_POSNORMAL", "0x0100");
903 Builder.defineMacro("__FPCLASS_POSINF", "0x0200");
904
905 // Support for #pragma redefine_extname (Sun compatibility)
906 Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");
907
908 // Previously this macro was set to a string aiming to achieve compatibility
909 // with GCC 4.2.1. Now, just return the full Clang version
910 Builder.defineMacro("__VERSION__", "\"" +
911 Twine(getClangFullCPPVersion()) + "\"");
912
913 // Initialize language-specific preprocessor defines.
914
915 // Standard conforming mode?
916 if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)
917 Builder.defineMacro("__STRICT_ANSI__");
918
919 if (LangOpts.GNUCVersion && LangOpts.CPlusPlus11)
920 Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");
921
922 if (TI.getTriple().isOSCygMing()) {
923 // Set ABI defining macros for libstdc++ for MinGW and Cygwin, where the
924 // default in libstdc++ differs from the defaults for this target.
925 Builder.defineMacro("__GXX_TYPEINFO_EQUALITY_INLINE", "0");
926 }
927
928 if (LangOpts.ObjC) {
929 if (LangOpts.ObjCRuntime.isNonFragile()) {
930 Builder.defineMacro("__OBJC2__");
931
932 if (LangOpts.ObjCExceptions)
933 Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS");
934 }
935
936 if (LangOpts.getGC() != LangOptions::NonGC)
937 Builder.defineMacro("__OBJC_GC__");
938
939 if (LangOpts.ObjCRuntime.isNeXTFamily())
940 Builder.defineMacro("__NEXT_RUNTIME__");
941
942 if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::GNUstep) {
943 auto version = LangOpts.ObjCRuntime.getVersion();
944 // Don't rely on the tuple argument, because we can be asked to target
945 // later ABIs than we actually support, so clamp these values to those
946 // currently supported
947 if (version >= VersionTuple(2, 0))
948 Builder.defineMacro("__OBJC_GNUSTEP_RUNTIME_ABI__", "20");
949 else
950 Builder.defineMacro(
951 "__OBJC_GNUSTEP_RUNTIME_ABI__",
952 "1" + Twine(std::min(8U, version.getMinor().value_or(0))));
953 }
954
955 if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::ObjFW) {
956 VersionTuple tuple = LangOpts.ObjCRuntime.getVersion();
957 unsigned minor = tuple.getMinor().value_or(0);
958 unsigned subminor = tuple.getSubminor().value_or(0);
959 Builder.defineMacro("__OBJFW_RUNTIME_ABI__",
960 Twine(tuple.getMajor() * 10000 + minor * 100 +
961 subminor));
962 }
963
964 Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))");
965 Builder.defineMacro("IBOutletCollection(ClassName)",
966 "__attribute__((iboutletcollection(ClassName)))");
967 Builder.defineMacro("IBAction", "void)__attribute__((ibaction)");
968 Builder.defineMacro("IBInspectable", "");
969 Builder.defineMacro("IB_DESIGNABLE", "");
970 }
971
972 // Define a macro that describes the Objective-C boolean type even for C
973 // and C++ since BOOL can be used from non Objective-C code.
974 Builder.defineMacro("__OBJC_BOOL_IS_BOOL",
975 Twine(TI.useSignedCharForObjCBool() ? "0" : "1"));
976
977 if (LangOpts.CPlusPlus)
978 InitializeCPlusPlusFeatureTestMacros(LangOpts, Builder);
979
980 // darwin_constant_cfstrings controls this. This is also dependent
981 // on other things like the runtime I believe. This is set even for C code.
982 if (!LangOpts.NoConstantCFStrings)
983 Builder.defineMacro("__CONSTANT_CFSTRINGS__");
984
985 if (LangOpts.ObjC)
986 Builder.defineMacro("OBJC_NEW_PROPERTIES");
987
988 if (LangOpts.PascalStrings)
989 Builder.defineMacro("__PASCAL_STRINGS__");
990
991 if (LangOpts.Blocks) {
992 Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");
993 Builder.defineMacro("__BLOCKS__");
994 }
995
996 if (!LangOpts.MSVCCompat && LangOpts.Exceptions)
997 Builder.defineMacro("__EXCEPTIONS");
998 if (LangOpts.GNUCVersion && LangOpts.RTTI)
999 Builder.defineMacro("__GXX_RTTI");
1000
1001 if (CGOpts.hasSjLjExceptions())
1002 Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
1003 else if (CGOpts.hasSEHExceptions())
1004 Builder.defineMacro("__SEH__");
1005 else if (CGOpts.hasDWARFExceptions() &&
1006 (TI.getTriple().isThumb() || TI.getTriple().isARM()))
1007 Builder.defineMacro("__ARM_DWARF_EH__");
1008 else if (CGOpts.hasWasmExceptions() && TI.getTriple().isWasm())
1009 Builder.defineMacro("__WASM_EXCEPTIONS__");
1010
1011 if (LangOpts.Deprecated)
1012 Builder.defineMacro("__DEPRECATED");
1013
1014 if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus)
1015 Builder.defineMacro("__private_extern__", "extern");
1016
1017 if (LangOpts.MicrosoftExt) {
1018 if (LangOpts.WChar) {
1019 // wchar_t supported as a keyword.
1020 Builder.defineMacro("_WCHAR_T_DEFINED");
1021 Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED");
1022 }
1023 }
1024
1025 // Macros to help identify the narrow and wide character sets
1026 // FIXME: clang currently ignores -fexec-charset=. If this changes,
1027 // then this may need to be updated.
1028 Builder.defineMacro("__clang_literal_encoding__", "\"UTF-8\"");
1029 if (TI.getTypeWidth(TI.getWCharType()) >= 32) {
1030 // FIXME: 32-bit wchar_t signals UTF-32. This may change
1031 // if -fwide-exec-charset= is ever supported.
1032 Builder.defineMacro("__clang_wide_literal_encoding__", "\"UTF-32\"");
1033 } else {
1034 // FIXME: Less-than 32-bit wchar_t generally means UTF-16
1035 // (e.g., Windows, 32-bit IBM). This may need to be
1036 // updated if -fwide-exec-charset= is ever supported.
1037 Builder.defineMacro("__clang_wide_literal_encoding__", "\"UTF-16\"");
1038 }
1039
1040 if (CGOpts.OptimizationLevel != 0)
1041 Builder.defineMacro("__OPTIMIZE__");
1042 if (CGOpts.OptimizeSize != 0)
1043 Builder.defineMacro("__OPTIMIZE_SIZE__");
1044
1045 if (LangOpts.FastMath)
1046 Builder.defineMacro("__FAST_MATH__");
1047
1048 // Initialize target-specific preprocessor defines.
1049
1050 // __BYTE_ORDER__ was added in GCC 4.6. It's analogous
1051 // to the macro __BYTE_ORDER (no trailing underscores)
1052 // from glibc's <endian.h> header.
1053 // We don't support the PDP-11 as a target, but include
1054 // the define so it can still be compared against.
1055 Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234");
1056 Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321");
1057 Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412");
1058 if (TI.isBigEndian()) {
1059 Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__");
1060 Builder.defineMacro("__BIG_ENDIAN__");
1061 } else {
1062 Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__");
1063 Builder.defineMacro("__LITTLE_ENDIAN__");
1064 }
1065
1066 if (TI.getPointerWidth(LangAS::Default) == 64 && TI.getLongWidth() == 64 &&
1067 TI.getIntWidth() == 32) {
1068 Builder.defineMacro("_LP64");
1069 Builder.defineMacro("__LP64__");
1070 }
1071
1072 if (TI.getPointerWidth(LangAS::Default) == 32 && TI.getLongWidth() == 32 &&
1073 TI.getIntWidth() == 32) {
1074 Builder.defineMacro("_ILP32");
1075 Builder.defineMacro("__ILP32__");
1076 }
1077
1078 // Define type sizing macros based on the target properties.
1079 assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");
1080 Builder.defineMacro("__CHAR_BIT__", Twine(TI.getCharWidth()));
1081
1082 // The macro is specifying the number of bits in the width, not the number of
1083 // bits the object requires for its in-memory representation, which is what
1084 // getBoolWidth() will return. The bool/_Bool data type is only ever one bit
1085 // wide. See C23 6.2.6.2p2 for the rules in C. Note that
1086 // C++23 [basic.fundamental]p10 allows an implementation-defined value
1087 // representation for bool; when lowering to LLVM, Clang represents bool as an
1088 // i8 in memory but as an i1 when the value is needed, so '1' is also correct
1089 // for C++.
1090 Builder.defineMacro("__BOOL_WIDTH__", "1");
1091 Builder.defineMacro("__SHRT_WIDTH__", Twine(TI.getShortWidth()));
1092 Builder.defineMacro("__INT_WIDTH__", Twine(TI.getIntWidth()));
1093 Builder.defineMacro("__LONG_WIDTH__", Twine(TI.getLongWidth()));
1094 Builder.defineMacro("__LLONG_WIDTH__", Twine(TI.getLongLongWidth()));
1095
1096 size_t BitIntMaxWidth = TI.getMaxBitIntWidth();
1097 assert(BitIntMaxWidth <= llvm::IntegerType::MAX_INT_BITS &&
1098 "Target defined a max bit width larger than LLVM can support!");
1099 assert(BitIntMaxWidth >= TI.getLongLongWidth() &&
1100 "Target defined a max bit width smaller than the C standard allows!");
1101 Builder.defineMacro("__BITINT_MAXWIDTH__", Twine(BitIntMaxWidth));
1102
1103 DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder);
1104 DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder);
1105 DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder);
1106 DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder);
1107 DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder);
1108 DefineTypeSizeAndWidth("__WCHAR", TI.getWCharType(), TI, Builder);
1109 DefineTypeSizeAndWidth("__WINT", TI.getWIntType(), TI, Builder);
1110 DefineTypeSizeAndWidth("__INTMAX", TI.getIntMaxType(), TI, Builder);
1111 DefineTypeSizeAndWidth("__SIZE", TI.getSizeType(), TI, Builder);
1112
1113 DefineTypeSizeAndWidth("__UINTMAX", TI.getUIntMaxType(), TI, Builder);
1115 Builder);
1116 DefineTypeSizeAndWidth("__INTPTR", TI.getIntPtrType(), TI, Builder);
1117 DefineTypeSizeAndWidth("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
1118
1119 DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder);
1120 DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder);
1121 DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder);
1122 DefineTypeSizeof("__SIZEOF_LONG__", TI.getLongWidth(), TI, Builder);
1123 DefineTypeSizeof("__SIZEOF_LONG_DOUBLE__",TI.getLongDoubleWidth(),TI,Builder);
1124 DefineTypeSizeof("__SIZEOF_LONG_LONG__", TI.getLongLongWidth(), TI, Builder);
1125 DefineTypeSizeof("__SIZEOF_POINTER__", TI.getPointerWidth(LangAS::Default),
1126 TI, Builder);
1127 DefineTypeSizeof("__SIZEOF_SHORT__", TI.getShortWidth(), TI, Builder);
1128 DefineTypeSizeof("__SIZEOF_PTRDIFF_T__",
1130 Builder);
1131 DefineTypeSizeof("__SIZEOF_SIZE_T__",
1132 TI.getTypeWidth(TI.getSizeType()), TI, Builder);
1133 DefineTypeSizeof("__SIZEOF_WCHAR_T__",
1134 TI.getTypeWidth(TI.getWCharType()), TI, Builder);
1135 DefineTypeSizeof("__SIZEOF_WINT_T__",
1136 TI.getTypeWidth(TI.getWIntType()), TI, Builder);
1137 if (TI.hasInt128Type())
1138 DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder);
1139
1140 DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder);
1141 DefineFmt(LangOpts, "__INTMAX", TI.getIntMaxType(), TI, Builder);
1142 StringRef ConstSuffix(TI.getTypeConstantSuffix(TI.getIntMaxType()));
1143 Builder.defineMacro("__INTMAX_C_SUFFIX__", ConstSuffix);
1144 Builder.defineMacro("__INTMAX_C(c)",
1145 ConstSuffix.size() ? Twine("c##") + ConstSuffix : "c");
1146 DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder);
1147 DefineFmt(LangOpts, "__UINTMAX", TI.getUIntMaxType(), TI, Builder);
1148 ConstSuffix = TI.getTypeConstantSuffix(TI.getUIntMaxType());
1149 Builder.defineMacro("__UINTMAX_C_SUFFIX__", ConstSuffix);
1150 Builder.defineMacro("__UINTMAX_C(c)",
1151 ConstSuffix.size() ? Twine("c##") + ConstSuffix : "c");
1152 DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(LangAS::Default), Builder);
1153 DefineFmt(LangOpts, "__PTRDIFF", TI.getPtrDiffType(LangAS::Default), TI,
1154 Builder);
1155 DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder);
1156 DefineFmt(LangOpts, "__INTPTR", TI.getIntPtrType(), TI, Builder);
1157 DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder);
1158 DefineFmt(LangOpts, "__SIZE", TI.getSizeType(), TI, Builder);
1159 DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder);
1160 DefineType("__WINT_TYPE__", TI.getWIntType(), Builder);
1161 DefineTypeSizeAndWidth("__SIG_ATOMIC", TI.getSigAtomicType(), TI, Builder);
1162 if (LangOpts.C23)
1163 DefineType("__CHAR8_TYPE__", TI.UnsignedChar, Builder);
1164 DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder);
1165 DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder);
1166
1167 DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder);
1168 DefineFmt(LangOpts, "__UINTPTR", TI.getUIntPtrType(), TI, Builder);
1169
1170 // The C standard requires the width of uintptr_t and intptr_t to be the same,
1171 // per 7.20.2.4p1. Same for intmax_t and uintmax_t, per 7.20.2.5p1.
1172 assert(TI.getTypeWidth(TI.getUIntPtrType()) ==
1173 TI.getTypeWidth(TI.getIntPtrType()) &&
1174 "uintptr_t and intptr_t have different widths?");
1175 assert(TI.getTypeWidth(TI.getUIntMaxType()) ==
1176 TI.getTypeWidth(TI.getIntMaxType()) &&
1177 "uintmax_t and intmax_t have different widths?");
1178
1179 if (LangOpts.FixedPoint) {
1180 // Each unsigned type has the same width as their signed type.
1181 DefineFixedPointMacros(TI, Builder, "SFRACT", "HR", TI.getShortFractWidth(),
1182 TI.getShortFractScale(), /*Signed=*/true);
1183 DefineFixedPointMacros(TI, Builder, "USFRACT", "UHR",
1184 TI.getShortFractWidth(),
1185 TI.getUnsignedShortFractScale(), /*Signed=*/false);
1186 DefineFixedPointMacros(TI, Builder, "FRACT", "R", TI.getFractWidth(),
1187 TI.getFractScale(), /*Signed=*/true);
1188 DefineFixedPointMacros(TI, Builder, "UFRACT", "UR", TI.getFractWidth(),
1189 TI.getUnsignedFractScale(), /*Signed=*/false);
1190 DefineFixedPointMacros(TI, Builder, "LFRACT", "LR", TI.getLongFractWidth(),
1191 TI.getLongFractScale(), /*Signed=*/true);
1192 DefineFixedPointMacros(TI, Builder, "ULFRACT", "ULR",
1193 TI.getLongFractWidth(),
1194 TI.getUnsignedLongFractScale(), /*Signed=*/false);
1195 DefineFixedPointMacros(TI, Builder, "SACCUM", "HK", TI.getShortAccumWidth(),
1196 TI.getShortAccumScale(), /*Signed=*/true);
1197 DefineFixedPointMacros(TI, Builder, "USACCUM", "UHK",
1198 TI.getShortAccumWidth(),
1199 TI.getUnsignedShortAccumScale(), /*Signed=*/false);
1200 DefineFixedPointMacros(TI, Builder, "ACCUM", "K", TI.getAccumWidth(),
1201 TI.getAccumScale(), /*Signed=*/true);
1202 DefineFixedPointMacros(TI, Builder, "UACCUM", "UK", TI.getAccumWidth(),
1203 TI.getUnsignedAccumScale(), /*Signed=*/false);
1204 DefineFixedPointMacros(TI, Builder, "LACCUM", "LK", TI.getLongAccumWidth(),
1205 TI.getLongAccumScale(), /*Signed=*/true);
1206 DefineFixedPointMacros(TI, Builder, "ULACCUM", "ULK",
1207 TI.getLongAccumWidth(),
1208 TI.getUnsignedLongAccumScale(), /*Signed=*/false);
1209
1210 Builder.defineMacro("__SACCUM_IBIT__", Twine(TI.getShortAccumIBits()));
1211 Builder.defineMacro("__USACCUM_IBIT__",
1212 Twine(TI.getUnsignedShortAccumIBits()));
1213 Builder.defineMacro("__ACCUM_IBIT__", Twine(TI.getAccumIBits()));
1214 Builder.defineMacro("__UACCUM_IBIT__", Twine(TI.getUnsignedAccumIBits()));
1215 Builder.defineMacro("__LACCUM_IBIT__", Twine(TI.getLongAccumIBits()));
1216 Builder.defineMacro("__ULACCUM_IBIT__",
1217 Twine(TI.getUnsignedLongAccumIBits()));
1218 }
1219
1220 if (TI.hasFloat16Type())
1221 DefineFloatMacros(Builder, "FLT16", &TI.getHalfFormat(), "F16");
1222 DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
1223 DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
1224 DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
1225
1226 // Define a __POINTER_WIDTH__ macro for stdint.h.
1227 Builder.defineMacro("__POINTER_WIDTH__",
1228 Twine((int)TI.getPointerWidth(LangAS::Default)));
1229
1230 // Define __BIGGEST_ALIGNMENT__ to be compatible with gcc.
1231 Builder.defineMacro("__BIGGEST_ALIGNMENT__",
1232 Twine(TI.getSuitableAlign() / TI.getCharWidth()) );
1233
1234 if (!LangOpts.CharIsSigned)
1235 Builder.defineMacro("__CHAR_UNSIGNED__");
1236
1238 Builder.defineMacro("__WCHAR_UNSIGNED__");
1239
1241 Builder.defineMacro("__WINT_UNSIGNED__");
1242
1243 // Define exact-width integer types for stdint.h
1244 DefineExactWidthIntType(LangOpts, TargetInfo::SignedChar, TI, Builder);
1245
1246 if (TI.getShortWidth() > TI.getCharWidth())
1247 DefineExactWidthIntType(LangOpts, TargetInfo::SignedShort, TI, Builder);
1248
1249 if (TI.getIntWidth() > TI.getShortWidth())
1250 DefineExactWidthIntType(LangOpts, TargetInfo::SignedInt, TI, Builder);
1251
1252 if (TI.getLongWidth() > TI.getIntWidth())
1253 DefineExactWidthIntType(LangOpts, TargetInfo::SignedLong, TI, Builder);
1254
1255 if (TI.getLongLongWidth() > TI.getLongWidth())
1257
1258 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedChar, TI, Builder);
1261
1262 if (TI.getShortWidth() > TI.getCharWidth()) {
1263 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedShort, TI, Builder);
1266 }
1267
1268 if (TI.getIntWidth() > TI.getShortWidth()) {
1269 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedInt, TI, Builder);
1272 }
1273
1274 if (TI.getLongWidth() > TI.getIntWidth()) {
1275 DefineExactWidthIntType(LangOpts, TargetInfo::UnsignedLong, TI, Builder);
1278 }
1279
1280 if (TI.getLongLongWidth() > TI.getLongWidth()) {
1282 Builder);
1285 }
1286
1287 DefineLeastWidthIntType(LangOpts, 8, true, TI, Builder);
1288 DefineLeastWidthIntType(LangOpts, 8, false, TI, Builder);
1289 DefineLeastWidthIntType(LangOpts, 16, true, TI, Builder);
1290 DefineLeastWidthIntType(LangOpts, 16, false, TI, Builder);
1291 DefineLeastWidthIntType(LangOpts, 32, true, TI, Builder);
1292 DefineLeastWidthIntType(LangOpts, 32, false, TI, Builder);
1293 DefineLeastWidthIntType(LangOpts, 64, true, TI, Builder);
1294 DefineLeastWidthIntType(LangOpts, 64, false, TI, Builder);
1295
1296 DefineFastIntType(LangOpts, 8, true, TI, Builder);
1297 DefineFastIntType(LangOpts, 8, false, TI, Builder);
1298 DefineFastIntType(LangOpts, 16, true, TI, Builder);
1299 DefineFastIntType(LangOpts, 16, false, TI, Builder);
1300 DefineFastIntType(LangOpts, 32, true, TI, Builder);
1301 DefineFastIntType(LangOpts, 32, false, TI, Builder);
1302 DefineFastIntType(LangOpts, 64, true, TI, Builder);
1303 DefineFastIntType(LangOpts, 64, false, TI, Builder);
1304
1305 Builder.defineMacro("__USER_LABEL_PREFIX__", TI.getUserLabelPrefix());
1306
1307 if (!LangOpts.MathErrno)
1308 Builder.defineMacro("__NO_MATH_ERRNO__");
1309
1310 if (LangOpts.FastMath || (LangOpts.NoHonorInfs && LangOpts.NoHonorNaNs))
1311 Builder.defineMacro("__FINITE_MATH_ONLY__", "1");
1312 else
1313 Builder.defineMacro("__FINITE_MATH_ONLY__", "0");
1314
1315 if (LangOpts.GNUCVersion) {
1316 if (LangOpts.GNUInline || LangOpts.CPlusPlus)
1317 Builder.defineMacro("__GNUC_GNU_INLINE__");
1318 else
1319 Builder.defineMacro("__GNUC_STDC_INLINE__");
1320
1321 // The value written by __atomic_test_and_set.
1322 // FIXME: This is target-dependent.
1323 Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
1324 }
1325
1326 // GCC defines these macros in both C and C++ modes despite them being needed
1327 // mostly for STL implementations in C++.
1328 auto [Destructive, Constructive] = TI.hardwareInterferenceSizes();
1329 Builder.defineMacro("__GCC_DESTRUCTIVE_SIZE", Twine(Destructive));
1330 Builder.defineMacro("__GCC_CONSTRUCTIVE_SIZE", Twine(Constructive));
1331 // We need to use push_macro to allow users to redefine these macros from the
1332 // command line with -D and not issue a -Wmacro-redefined warning.
1333 Builder.append("#pragma push_macro(\"__GCC_DESTRUCTIVE_SIZE\")");
1334 Builder.append("#pragma push_macro(\"__GCC_CONSTRUCTIVE_SIZE\")");
1335
1336 auto addLockFreeMacros = [&](const llvm::Twine &Prefix) {
1337 // Used by libc++ and libstdc++ to implement ATOMIC_<foo>_LOCK_FREE.
1338#define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \
1339 Builder.defineMacro(Prefix + #TYPE "_LOCK_FREE", \
1340 getLockFreeValue(TI.get##Type##Width(), TI));
1342 DEFINE_LOCK_FREE_MACRO(CHAR, Char);
1343 // char8_t has the same representation / width as unsigned
1344 // char in C++ and is a typedef for unsigned char in C23
1345 if (LangOpts.Char8 || LangOpts.C23)
1346 DEFINE_LOCK_FREE_MACRO(CHAR8_T, Char);
1347 DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16);
1348 DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32);
1349 DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar);
1351 DEFINE_LOCK_FREE_MACRO(INT, Int);
1354 Builder.defineMacro(
1355 Prefix + "POINTER_LOCK_FREE",
1357#undef DEFINE_LOCK_FREE_MACRO
1358 };
1359 addLockFreeMacros("__CLANG_ATOMIC_");
1360 if (LangOpts.GNUCVersion)
1361 addLockFreeMacros("__GCC_ATOMIC_");
1362
1363 if (CGOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining)
1364 Builder.defineMacro("__NO_INLINE__");
1365
1366 if (unsigned PICLevel = LangOpts.PICLevel) {
1367 Builder.defineMacro("__PIC__", Twine(PICLevel));
1368 Builder.defineMacro("__pic__", Twine(PICLevel));
1369 if (LangOpts.PIE) {
1370 Builder.defineMacro("__PIE__", Twine(PICLevel));
1371 Builder.defineMacro("__pie__", Twine(PICLevel));
1372 }
1373 }
1374
1375 // Macros to control C99 numerics and <float.h>
1376 Builder.defineMacro("__FLT_RADIX__", "2");
1377 Builder.defineMacro("__DECIMAL_DIG__", "__LDBL_DECIMAL_DIG__");
1378
1379 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
1380 Builder.defineMacro("__SSP__");
1381 else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
1382 Builder.defineMacro("__SSP_STRONG__", "2");
1383 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
1384 Builder.defineMacro("__SSP_ALL__", "3");
1385
1386 if (PPOpts.SetUpStaticAnalyzer)
1387 Builder.defineMacro("__clang_analyzer__");
1388
1389 if (LangOpts.FastRelaxedMath)
1390 Builder.defineMacro("__FAST_RELAXED_MATH__");
1391
1392 if (FEOpts.ProgramAction == frontend::RewriteObjC ||
1393 LangOpts.getGC() != LangOptions::NonGC) {
1394 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
1395 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
1396 Builder.defineMacro("__autoreleasing", "");
1397 Builder.defineMacro("__unsafe_unretained", "");
1398 } else if (LangOpts.ObjC) {
1399 Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))");
1400 Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))");
1401 Builder.defineMacro("__autoreleasing",
1402 "__attribute__((objc_ownership(autoreleasing)))");
1403 Builder.defineMacro("__unsafe_unretained",
1404 "__attribute__((objc_ownership(none)))");
1405 }
1406
1407 // On Darwin, there are __double_underscored variants of the type
1408 // nullability qualifiers.
1409 if (TI.getTriple().isOSDarwin()) {
1410 Builder.defineMacro("__nonnull", "_Nonnull");
1411 Builder.defineMacro("__null_unspecified", "_Null_unspecified");
1412 Builder.defineMacro("__nullable", "_Nullable");
1413 }
1414
1415 // Add a macro to differentiate between regular iOS/tvOS/watchOS targets and
1416 // the corresponding simulator targets.
1417 if (TI.getTriple().isOSDarwin() && TI.getTriple().isSimulatorEnvironment())
1418 Builder.defineMacro("__APPLE_EMBEDDED_SIMULATOR__", "1");
1419
1420 // OpenMP definition
1421 // OpenMP 2.2:
1422 // In implementations that support a preprocessor, the _OPENMP
1423 // macro name is defined to have the decimal value yyyymm where
1424 // yyyy and mm are the year and the month designations of the
1425 // version of the OpenMP API that the implementation support.
1426 if (!LangOpts.OpenMPSimd) {
1427 switch (LangOpts.OpenMP) {
1428 case 0:
1429 break;
1430 case 31:
1431 Builder.defineMacro("_OPENMP", "201107");
1432 break;
1433 case 40:
1434 Builder.defineMacro("_OPENMP", "201307");
1435 break;
1436 case 45:
1437 Builder.defineMacro("_OPENMP", "201511");
1438 break;
1439 case 50:
1440 Builder.defineMacro("_OPENMP", "201811");
1441 break;
1442 case 51:
1443 Builder.defineMacro("_OPENMP", "202011");
1444 break;
1445 case 52:
1446 Builder.defineMacro("_OPENMP", "202111");
1447 break;
1448 case 60:
1449 Builder.defineMacro("_OPENMP", "202411");
1450 break;
1451 default: // case 51:
1452 // Default version is OpenMP 5.1
1453 Builder.defineMacro("_OPENMP", "202011");
1454 break;
1455 }
1456 }
1457
1458 // CUDA device path compilaton
1459 if (LangOpts.CUDAIsDevice && !LangOpts.HIP) {
1460 // The CUDA_ARCH value is set for the GPU target specified in the NVPTX
1461 // backend's target defines.
1462 Builder.defineMacro("__CUDA_ARCH__");
1463 }
1464
1465 // We need to communicate this to our CUDA/HIP header wrapper, which in turn
1466 // informs the proper CUDA/HIP headers of this choice.
1467 if (LangOpts.GPUDeviceApproxTranscendentals)
1468 Builder.defineMacro("__CLANG_GPU_APPROX_TRANSCENDENTALS__");
1469
1470 // Define a macro indicating that the source file is being compiled with a
1471 // SYCL device compiler which doesn't produce host binary.
1472 if (LangOpts.SYCLIsDevice) {
1473 Builder.defineMacro("__SYCL_DEVICE_ONLY__", "1");
1474 }
1475
1476 // OpenCL definitions.
1477 if (LangOpts.OpenCL) {
1478 InitializeOpenCLFeatureTestMacros(TI, LangOpts, Builder);
1479
1480 if (TI.getTriple().isSPIR() || TI.getTriple().isSPIRV())
1481 Builder.defineMacro("__IMAGE_SUPPORT__");
1482 }
1483
1484 if (TI.hasInt128Type() && LangOpts.CPlusPlus && LangOpts.GNUMode) {
1485 // For each extended integer type, g++ defines a macro mapping the
1486 // index of the type (0 in this case) in some list of extended types
1487 // to the type.
1488 Builder.defineMacro("__GLIBCXX_TYPE_INT_N_0", "__int128");
1489 Builder.defineMacro("__GLIBCXX_BITSIZE_INT_N_0", "128");
1490 }
1491
1492 // ELF targets define __ELF__
1493 if (TI.getTriple().isOSBinFormatELF())
1494 Builder.defineMacro("__ELF__");
1495
1496 if (LangOpts.Sanitize.hasOneOf(SanitizerKind::Address |
1497 SanitizerKind::KernelAddress))
1498 Builder.defineMacro("__SANITIZE_ADDRESS__");
1499 if (LangOpts.Sanitize.hasOneOf(SanitizerKind::HWAddress |
1500 SanitizerKind::KernelHWAddress))
1501 Builder.defineMacro("__SANITIZE_HWADDRESS__");
1502 if (LangOpts.Sanitize.has(SanitizerKind::Thread))
1503 Builder.defineMacro("__SANITIZE_THREAD__");
1504 if (LangOpts.Sanitize.has(SanitizerKind::AllocToken))
1505 Builder.defineMacro("__SANITIZE_ALLOC_TOKEN__");
1506
1507 // Target OS macro definitions.
1508 if (PPOpts.DefineTargetOSMacros) {
1509 const llvm::Triple &Triple = TI.getTriple();
1510#define TARGET_OS(Name, Predicate) \
1511 Builder.defineMacro(#Name, (Predicate) ? "1" : "0");
1512#include "clang/Basic/TargetOSMacros.def"
1513#undef TARGET_OS
1514 }
1515
1516 if (LangOpts.PointerAuthIntrinsics)
1517 Builder.defineMacro("__PTRAUTH__");
1518
1519 // Get other target #defines.
1520 TI.getTargetDefines(LangOpts, Builder);
1521}
1522
1523static void InitializePGOProfileMacros(const CodeGenOptions &CodeGenOpts,
1524 MacroBuilder &Builder) {
1525 if (CodeGenOpts.hasProfileInstr())
1526 Builder.defineMacro("__LLVM_INSTR_PROFILE_GENERATE");
1527
1528 if (CodeGenOpts.hasProfileIRUse() || CodeGenOpts.hasProfileClangUse())
1529 Builder.defineMacro("__LLVM_INSTR_PROFILE_USE");
1530}
1531
1532/// InitializePreprocessor - Initialize the preprocessor getting it and the
1533/// environment ready to process a single file.
1535 const PreprocessorOptions &InitOpts,
1536 const PCHContainerReader &PCHContainerRdr,
1537 const FrontendOptions &FEOpts,
1538 const CodeGenOptions &CodeGenOpts) {
1539 const LangOptions &LangOpts = PP.getLangOpts();
1540 std::string PredefineBuffer;
1541 PredefineBuffer.reserve(4080);
1542 llvm::raw_string_ostream Predefines(PredefineBuffer);
1543 MacroBuilder Builder(Predefines);
1544
1545 // Emit line markers for various builtin sections of the file. The 3 here
1546 // marks <built-in> as being a system header, which suppresses warnings when
1547 // the same macro is defined multiple times.
1548 Builder.append("# 1 \"<built-in>\" 3");
1549
1550 // Install things like __POWERPC__, __GNUC__, etc into the macro table.
1551 if (InitOpts.UsePredefines) {
1552 // FIXME: This will create multiple definitions for most of the predefined
1553 // macros. This is not the right way to handle this.
1554 if ((LangOpts.CUDA || LangOpts.isTargetDevice()) && PP.getAuxTargetInfo())
1555 InitializePredefinedMacros(*PP.getAuxTargetInfo(), LangOpts, FEOpts,
1556 PP.getPreprocessorOpts(), CodeGenOpts,
1557 Builder);
1558
1559 InitializePredefinedMacros(PP.getTargetInfo(), LangOpts, FEOpts,
1560 PP.getPreprocessorOpts(), CodeGenOpts, Builder);
1561
1562 // Install definitions to make Objective-C++ ARC work well with various
1563 // C++ Standard Library implementations.
1564 if (LangOpts.ObjC && LangOpts.CPlusPlus &&
1565 (LangOpts.ObjCAutoRefCount || LangOpts.ObjCWeak)) {
1566 switch (InitOpts.ObjCXXARCStandardLibrary) {
1567 case ARCXX_nolib:
1568 case ARCXX_libcxx:
1569 break;
1570
1571 case ARCXX_libstdcxx:
1572 AddObjCXXARCLibstdcxxDefines(LangOpts, Builder);
1573 break;
1574 }
1575 }
1576 }
1577
1578 // Even with predefines off, some macros are still predefined.
1579 // These should all be defined in the preprocessor according to the
1580 // current language configuration.
1582 FEOpts, Builder);
1583
1584 // The PGO instrumentation profile macros are driven by options
1585 // -fprofile[-instr]-generate/-fcs-profile-generate/-fprofile[-instr]-use,
1586 // hence they are not guarded by InitOpts.UsePredefines.
1587 InitializePGOProfileMacros(CodeGenOpts, Builder);
1588
1589 // Add on the predefines from the driver. Wrap in a #line directive to report
1590 // that they come from the command line.
1591 Builder.append("# 1 \"<command line>\" 1");
1592
1593 // Process #define's and #undef's in the order they are given.
1594 for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
1595 if (InitOpts.Macros[i].second) // isUndef
1596 Builder.undefineMacro(InitOpts.Macros[i].first);
1597 else
1598 DefineBuiltinMacro(Builder, InitOpts.Macros[i].first,
1599 PP.getDiagnostics());
1600 }
1601
1602 // Exit the command line and go back to <built-in> (2 is LC_LEAVE).
1603 Builder.append("# 1 \"<built-in>\" 2");
1604
1605 // If -imacros are specified, include them now. These are processed before
1606 // any -include directives.
1607 for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
1608 AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i]);
1609
1610 // Process -include-pch/-include-pth directives.
1611 if (!InitOpts.ImplicitPCHInclude.empty())
1612 AddImplicitIncludePCH(Builder, PP, PCHContainerRdr,
1613 InitOpts.ImplicitPCHInclude);
1614
1615 // Process -include directives.
1616 for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {
1617 const std::string &Path = InitOpts.Includes[i];
1618 AddImplicitInclude(Builder, Path);
1619 }
1620
1621 // Instruct the preprocessor to skip the preamble.
1623 InitOpts.PrecompiledPreambleBytes.second);
1624
1625 // Copy PredefinedBuffer into the Preprocessor.
1626 PP.setPredefines(std::move(PredefineBuffer));
1627
1628 // Match gcc behavior regarding gnu-line-directive diagnostics, assuming that
1629 // '-x <*>-cpp-output' is analogous to '-fpreprocessed'.
1630 if (FEOpts.DashX.isPreprocessed()) {
1631 PP.getDiagnostics().setSeverity(diag::ext_pp_gnu_line_directive,
1633 }
1634}
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 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)
static void InitializePredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, const PreprocessorOptions &PPOpts, const CodeGenOptions &CGOpts, 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:1999
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
bool hasDWARFExceptions() const
bool hasProfileInstr() const
Check if any form of instrumentation is on.
bool hasProfileIRUse() const
Check if IR level profile use is on.
bool hasWasmExceptions() const
bool hasSjLjExceptions() const
bool hasSEHExceptions() const
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:232
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc)
This allows the client to specify that certain warnings are ignored.
FrontendOptions - Options for controlling the behavior of the frontend.
InputKind DashX
The input kind, either specified via -x argument or deduced from the input file name.
frontend::ActionKind ProgramAction
The frontend action to perform.
bool isPreprocessed() const
@ PerThread
Per-thread default stream.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
clang::ObjCRuntime ObjCRuntime
SanitizerSet Sanitize
Set of enabled sanitizers.
bool isTargetDevice() const
True when compiling for an offloading target device.
std::optional< uint32_t > getCPlusPlusLangStd() const
Returns the most applicable C++ standard-compliant language version code.
std::optional< uint32_t > getCLangStd() const
Returns the most applicable C standard-compliant language version code.
GPUDefaultStreamKind GPUDefaultStream
The default stream kind used for HIP kernel launching.
Kind getKind() const
Definition ObjCRuntime.h:77
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
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.
const TargetInfo * getAuxTargetInfo() const
const TargetInfo & getTargetInfo() const
FileManager & getFileManager() const
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 PreprocessorOptions & getPreprocessorOpts() const
Retrieve the preprocessor options used to initialize this preprocessor.
const LangOptions & getLangOpts() const
DiagnosticsEngine & getDiagnostics() const
Encodes a location in the source.
Exposes information about the current target.
Definition TargetInfo.h:226
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with 'operator new(size_t)' is gua...
Definition TargetInfo.h:761
unsigned getUnsignedLongFractScale() const
getUnsignedLongFractScale - Return the number of fractional bits in a 'unsigned long _Fract' type.
Definition TargetInfo.h:667
unsigned getShortWidth() const
getShortWidth/Align - Return the size of 'signed short' and 'unsigned short' for this target,...
Definition TargetInfo.h:522
unsigned getUnsignedAccumScale() const
getUnsignedAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned _Accum' ty...
Definition TargetInfo.h:621
unsigned getUnsignedAccumIBits() const
Definition TargetInfo.h:624
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
unsigned getAccumWidth() const
getAccumWidth/Align - Return the size of 'signed _Accum' and 'unsigned _Accum' for this target,...
Definition TargetInfo.h:566
IntType getUIntPtrType() const
Definition TargetInfo.h:412
IntType getInt64Type() const
Definition TargetInfo.h:419
unsigned getUnsignedFractScale() const
getUnsignedFractScale - Return the number of fractional bits in a 'unsigned _Fract' type.
Definition TargetInfo.h:661
virtual IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return the smallest integer type with at least the specified width.
virtual bool hasFeatureEnabled(const llvm::StringMap< bool > &Features, StringRef Name) const
Check if target has a given feature enabled.
virtual size_t getMaxBitIntWidth() const
Definition TargetInfo.h:690
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
unsigned getLongAccumScale() const
getLongAccumScale/IBits - Return the number of fractional/integral bits in a 'signed long _Accum' typ...
Definition TargetInfo.h:603
unsigned getLongFractScale() const
getLongFractScale - Return the number of fractional bits in a 'signed long _Fract' type.
Definition TargetInfo.h:650
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition TargetInfo.h:486
static bool isTypeSigned(IntType T)
Returns true if the type is signed; false otherwise.
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...
bool useSignedCharForObjCBool() const
Check if the Objective-C built-in boolean type should be signed char.
Definition TargetInfo.h:933
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition TargetInfo.h:673
unsigned getAccumIBits() const
Definition TargetInfo.h:599
IntType getSigAtomicType() const
Definition TargetInfo.h:427
unsigned getAccumScale() const
getAccumScale/IBits - Return the number of fractional/integral bits in a 'signed _Accum' type.
Definition TargetInfo.h:598
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
Definition TargetInfo.h:715
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
Definition TargetInfo.h:527
IntType getPtrDiffType(LangAS AddrSpace) const
Definition TargetInfo.h:404
bool isLittleEndian() const
unsigned getShortAccumIBits() const
Definition TargetInfo.h:592
unsigned getFloatWidth() const
getFloatWidth/Align/Format - Return the size/align/format of 'float'.
Definition TargetInfo.h:786
unsigned getLongAccumIBits() const
Definition TargetInfo.h:604
IntType getSizeType() const
Definition TargetInfo.h:385
IntType getWIntType() const
Definition TargetInfo.h:416
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:571
unsigned getShortAccumScale() const
getShortAccumScale/IBits - Return the number of fractional/integral bits in a 'signed short _Accum' t...
Definition TargetInfo.h:591
const llvm::fltSemantics & getDoubleFormat() const
Definition TargetInfo.h:798
static const char * getTypeName(IntType T)
Return the user string for the specified integer type enum.
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
Definition TargetInfo.h:537
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:859
IntType getIntPtrType() const
Definition TargetInfo.h:411
IntType getInt16Type() const
Definition TargetInfo.h:423
const llvm::fltSemantics & getHalfFormat() const
Definition TargetInfo.h:783
llvm::StringMap< bool > & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
IntType getWCharType() const
Definition TargetInfo.h:415
IntType getUInt16Type() const
Definition TargetInfo.h:424
bool isBigEndian() const
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:921
IntType getChar16Type() const
Definition TargetInfo.h:417
unsigned getUnsignedShortAccumIBits() const
Definition TargetInfo.h:613
IntType getChar32Type() const
Definition TargetInfo.h:418
IntType getUInt64Type() const
Definition TargetInfo.h:420
unsigned getUnsignedLongAccumScale() const
getUnsignedLongAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned long _...
Definition TargetInfo.h:631
unsigned getUnsignedLongAccumIBits() const
Definition TargetInfo.h:634
unsigned getUnsignedShortFractScale() const
getUnsignedShortFractScale - Return the number of fractional bits in a 'unsigned short _Fract' type.
Definition TargetInfo.h:654
const llvm::fltSemantics & getLongDoubleFormat() const
Definition TargetInfo.h:804
const llvm::fltSemantics & getFloatFormat() const
Definition TargetInfo.h:788
const char * getTypeConstantSuffix(IntType T) const
Return the constant suffix for the specified integer type enum.
unsigned getDoubleWidth() const
getDoubleWidth/Align/Format - Return the size/align/format of 'double'.
Definition TargetInfo.h:796
unsigned getShortAccumWidth() const
getShortAccumWidth/Align - Return the size of 'signed short _Accum' and 'unsigned short _Accum' for t...
Definition TargetInfo.h:561
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:742
unsigned getCharWidth() const
Definition TargetInfo.h:517
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
Definition TargetInfo.h:532
unsigned getLongFractWidth() const
getLongFractWidth/Align - Return the size of 'signed long _Fract' and 'unsigned long _Fract' for this...
Definition TargetInfo.h:586
IntType getIntMaxType() const
Definition TargetInfo.h:400
unsigned getFractScale() const
getFractScale - Return the number of fractional bits in a 'signed _Fract' type.
Definition TargetInfo.h:646
unsigned getFractWidth() const
getFractWidth/Align - Return the size of 'signed _Fract' and 'unsigned _Fract' for this target,...
Definition TargetInfo.h:581
unsigned getShortFractScale() const
getShortFractScale - Return the number of fractional bits in a 'signed short _Fract' type.
Definition TargetInfo.h:642
unsigned getShortFractWidth() const
getShortFractWidth/Align - Return the size of 'signed short _Fract' and 'unsigned short _Fract' for t...
Definition TargetInfo.h:576
virtual bool hasHIPImageSupport() const
Whether to support HIP image/texture API's.
static const char * getTypeFormatModifier(IntType T)
Return the printf format modifier for the specified integer type enum.
unsigned getUnsignedShortAccumScale() const
getUnsignedShortAccumScale/IBits - Return the number of fractional/integral bits in a 'unsigned short...
Definition TargetInfo.h:610
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:451
IntType getUIntMaxType() const
Definition TargetInfo.h:401
unsigned getLongDoubleWidth() const
getLongDoubleWidth/Align/Format - Return the size/align/format of 'long double'.
Definition TargetInfo.h:802
Defines the clang::TargetInfo interface.
@ Ignored
Do not present this diagnostic, ignore it.
@ RewriteObjC
ObjC->C Rewriter.
constexpr ShaderStage getStageFromEnvironment(const llvm::Triple::EnvironmentType &E)
Definition HLSLRuntime.h:24
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++
const FunctionProtoType * T
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
Definition CharInfo.h:108
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
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition Sanitizers.h:174
bool hasOneOf(SanitizerMask K) const
Check if one or more sanitizers are enabled.
Definition Sanitizers.h:184
IntType
===-— Target Data Type Query Methods ----------------------------—===//
Definition TargetInfo.h:146