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