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