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