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