| //===--- OSTargets.cpp - Implement OS target feature support --------------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file implements OS specific TargetInfo types. | |
| //===----------------------------------------------------------------------===// | |
| #include "OSTargets.h" | |
| #include "AArch64.h" | |
| #include "clang/Basic/MacroBuilder.h" | |
| #include "llvm/ADT/StringRef.h" | |
| using namespace clang; | |
| using namespace clang::targets; | |
| namespace clang { | |
| namespace targets { | |
| void getAppleMachODefines(MacroBuilder &Builder, const LangOptions &Opts, | |
| const llvm::Triple &Triple) { | |
| Builder.defineMacro("__APPLE_CC__", "6000"); | |
| Builder.defineMacro("__APPLE__"); | |
| // AddressSanitizer doesn't play well with source fortification, which is on | |
| // by default on Apple platforms. | |
| if (Opts.Sanitize.has(SanitizerKind::Address)) | |
| Builder.defineMacro("_FORTIFY_SOURCE", "0"); | |
| // Apple defines __weak, __strong, and __unsafe_unretained even in C mode. | |
| if (!Opts.ObjC) { | |
| // __weak is always defined, for use in blocks and with objc pointers. | |
| Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))"); | |
| Builder.defineMacro("__strong", ""); | |
| Builder.defineMacro("__unsafe_unretained", ""); | |
| } | |
| if (Opts.Static) | |
| Builder.defineMacro("__STATIC__"); | |
| else | |
| Builder.defineMacro("__DYNAMIC__"); | |
| if (Opts.POSIXThreads) | |
| Builder.defineMacro("_REENTRANT"); | |
| // __MACH__ originally meant "will run in a Mach kernel based OS", but it has | |
| // come to also mean "uses Apple Mach-O linking/symbol visibility semantics". | |
| // Notably libc++'s __configuration/platform.h and Swift's shims/Visibility.h | |
| // take __MACH__ for the more general meaning. | |
| if (Triple.isAppleMachO() || Triple.isOSDarwin()) | |
| Builder.defineMacro("__MACH__"); | |
| } | |
| void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, | |
| const llvm::Triple &Triple, StringRef &PlatformName, | |
| VersionTuple &PlatformMinVersion) { | |
| getAppleMachODefines(Builder, Opts, Triple); | |
| // Darwin's libc doesn't have threads.h | |
| Builder.defineMacro("__STDC_NO_THREADS__"); | |
| // Get the platform type and version number from the triple. | |
| VersionTuple OsVersion; | |
| if (Triple.isMacOSX()) { | |
| Triple.getMacOSXVersion(OsVersion); | |
| PlatformName = "macos"; | |
| } else { | |
| OsVersion = Triple.getOSVersion(); | |
| PlatformName = llvm::Triple::getOSTypeName(Triple.getOS()); | |
| if (PlatformName == "ios" && Triple.isMacCatalystEnvironment()) | |
| PlatformName = "maccatalyst"; | |
| } | |
| // If -target arch-pc-win32-macho option specified, we're | |
| // generating code for Win32 ABI. No need to emit | |
| // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__. | |
| if (PlatformName == "win32") { | |
| PlatformMinVersion = OsVersion; | |
| return; | |
| } | |
| assert(OsVersion < VersionTuple(100) && "Invalid version!"); | |
| char Str[7]; | |
| if (Triple.isMacOSX() && OsVersion < VersionTuple(10, 10)) { | |
| Str[0] = '0' + (OsVersion.getMajor() / 10); | |
| Str[1] = '0' + (OsVersion.getMajor() % 10); | |
| Str[2] = '0' + std::min(OsVersion.getMinor().value_or(0), 9U); | |
| Str[3] = '0' + std::min(OsVersion.getSubminor().value_or(0), 9U); | |
| Str[4] = '\0'; | |
| } else if (!Triple.isMacOSX() && OsVersion.getMajor() < 10) { | |
| Str[0] = '0' + OsVersion.getMajor(); | |
| Str[1] = '0' + (OsVersion.getMinor().value_or(0) / 10); | |
| Str[2] = '0' + (OsVersion.getMinor().value_or(0) % 10); | |
| Str[3] = '0' + (OsVersion.getSubminor().value_or(0) / 10); | |
| Str[4] = '0' + (OsVersion.getSubminor().value_or(0) % 10); | |
| Str[5] = '\0'; | |
| } else { | |
| // Handle versions >= 10. | |
| Str[0] = '0' + (OsVersion.getMajor() / 10); | |
| Str[1] = '0' + (OsVersion.getMajor() % 10); | |
| Str[2] = '0' + (OsVersion.getMinor().value_or(0) / 10); | |
| Str[3] = '0' + (OsVersion.getMinor().value_or(0) % 10); | |
| Str[4] = '0' + (OsVersion.getSubminor().value_or(0) / 10); | |
| Str[5] = '0' + (OsVersion.getSubminor().value_or(0) % 10); | |
| Str[6] = '\0'; | |
| } | |
| // Set the appropriate OS version define. | |
| if (Triple.isTvOS()) { | |
| Builder.defineMacro("__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__", Str); | |
| } else if (Triple.isiOS()) { | |
| Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str); | |
| } else if (Triple.isWatchOS()) { | |
| Builder.defineMacro("__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str); | |
| } else if (Triple.isDriverKit()) { | |
| assert(OsVersion.getMinor().value_or(0) < 100 && | |
| OsVersion.getSubminor().value_or(0) < 100 && "Invalid version!"); | |
| Builder.defineMacro("__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__", Str); | |
| } else if (Triple.isMacOSX()) { | |
| Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str); | |
| } | |
| if (Triple.isOSDarwin()) { | |
| // Any darwin OS defines a general darwin OS version macro in addition | |
| // to the other OS specific macros. | |
| assert(OsVersion.getMinor().value_or(0) < 100 && | |
| OsVersion.getSubminor().value_or(0) < 100 && "Invalid version!"); | |
| Builder.defineMacro("__ENVIRONMENT_OS_VERSION_MIN_REQUIRED__", Str); | |
| } | |
| PlatformMinVersion = OsVersion; | |
| } | |
| static void addMinGWDefines(const llvm::Triple &Triple, const LangOptions &Opts, | |
| MacroBuilder &Builder) { | |
| DefineStd(Builder, "WIN32", Opts); | |
| DefineStd(Builder, "WINNT", Opts); | |
| if (Triple.isArch64Bit()) { | |
| DefineStd(Builder, "WIN64", Opts); | |
| Builder.defineMacro("__MINGW64__"); | |
| } | |
| Builder.defineMacro("__MSVCRT__"); | |
| Builder.defineMacro("__MINGW32__"); | |
| addCygMingDefines(Opts, Builder); | |
| } | |
| static void addVisualCDefines(const LangOptions &Opts, MacroBuilder &Builder) { | |
| if (Opts.CPlusPlus) { | |
| if (Opts.RTTIData) | |
| Builder.defineMacro("_CPPRTTI"); | |
| if (Opts.CXXExceptions) | |
| Builder.defineMacro("_CPPUNWIND"); | |
| } | |
| if (Opts.Bool) | |
| Builder.defineMacro("__BOOL_DEFINED"); | |
| if (!Opts.CharIsSigned) | |
| Builder.defineMacro("_CHAR_UNSIGNED"); | |
| // "The /fp:contract option allows the compiler to generate floating-point | |
| // contractions [...]" | |
| if (Opts.getDefaultFPContractMode() != LangOptions::FPModeKind::FPM_Off) | |
| Builder.defineMacro("_M_FP_CONTRACT"); | |
| // "The /fp:except option generates code to ensures that any unmasked | |
| // floating-point exceptions are raised at the exact point at which they | |
| // occur, and that no other floating-point exceptions are raised." | |
| if (Opts.getDefaultExceptionMode() == | |
| LangOptions::FPExceptionModeKind::FPE_Strict) | |
| Builder.defineMacro("_M_FP_EXCEPT"); | |
| // "The /fp:fast option allows the compiler to reorder, combine, or simplify | |
| // floating-point operations to optimize floating-point code for speed and | |
| // space. The compiler may omit rounding at assignment statements, | |
| // typecasts, or function calls. It may reorder operations or make algebraic | |
| // transforms, for example, by use of associative and distributive laws. It | |
| // may reorder code even if such transformations result in observably | |
| // different rounding behavior." | |
| // | |
| // "Under /fp:precise and /fp:strict, the compiler doesn't do any mathematical | |
| // transformation unless the transformation is guaranteed to produce a bitwise | |
| // identical result." | |
| const bool any_imprecise_flags = Opts.FastMath || Opts.UnsafeFPMath || | |
| Opts.AllowFPReassoc || Opts.NoHonorNaNs || | |
| Opts.NoHonorInfs || Opts.NoSignedZero || | |
| Opts.AllowRecip || Opts.ApproxFunc; | |
| // "Under both /fp:precise and /fp:fast, the compiler generates code intended | |
| // to run in the default floating-point environment." | |
| // | |
| // "[The] default floating point environment [...] sets the rounding mode | |
| // to round to nearest." | |
| if (Opts.getDefaultRoundingMode() == | |
| LangOptions::RoundingMode::NearestTiesToEven) { | |
| if (any_imprecise_flags) { | |
| Builder.defineMacro("_M_FP_FAST"); | |
| } else { | |
| Builder.defineMacro("_M_FP_PRECISE"); | |
| } | |
| } else if (!any_imprecise_flags && Opts.getDefaultRoundingMode() == | |
| LangOptions::RoundingMode::Dynamic) { | |
| // "Under /fp:strict, the compiler generates code that allows the | |
| // program to safely unmask floating-point exceptions, read or write | |
| // floating-point status registers, or change rounding modes." | |
| Builder.defineMacro("_M_FP_STRICT"); | |
| } | |
| // FIXME: POSIXThreads isn't exactly the option this should be defined for, | |
| // but it works for now. | |
| if (Opts.POSIXThreads) | |
| Builder.defineMacro("_MT"); | |
| if (Opts.MSCompatibilityVersion) { | |
| Builder.defineMacro("_MSC_VER", | |
| Twine(Opts.MSCompatibilityVersion / 100000)); | |
| Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion)); | |
| // FIXME We cannot encode the revision information into 32-bits | |
| Builder.defineMacro("_MSC_BUILD", Twine(1)); | |
| // Exposed by MSVC, used in their stddef.h. | |
| Builder.defineMacro("_CRT_USE_BUILTIN_OFFSETOF", Twine(1)); | |
| if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) | |
| Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1)); | |
| if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) { | |
| if (Opts.CPlusPlus26) | |
| // TODO update to the proper value. | |
| Builder.defineMacro("_MSVC_LANG", "202400L"); | |
| else if (Opts.CPlusPlus23) | |
| Builder.defineMacro("_MSVC_LANG", "202302L"); | |
| else if (Opts.CPlusPlus20) | |
| Builder.defineMacro("_MSVC_LANG", "202002L"); | |
| else if (Opts.CPlusPlus17) | |
| Builder.defineMacro("_MSVC_LANG", "201703L"); | |
| else if (Opts.CPlusPlus14) | |
| Builder.defineMacro("_MSVC_LANG", "201402L"); | |
| } | |
| if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2022_3)) | |
| Builder.defineMacro("_MSVC_CONSTEXPR_ATTRIBUTE"); | |
| } | |
| if (Opts.MicrosoftExt) { | |
| Builder.defineMacro("_MSC_EXTENSIONS"); | |
| if (Opts.CPlusPlus11) { | |
| Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED"); | |
| Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED"); | |
| Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED"); | |
| } | |
| } | |
| if (!Opts.MSVolatile) | |
| Builder.defineMacro("_ISO_VOLATILE"); | |
| if (Opts.Kernel) | |
| Builder.defineMacro("_KERNEL_MODE"); | |
| Builder.defineMacro("_INTEGRAL_MAX_BITS", "64"); | |
| // Define __STDC_NO_THREADS__ based on MSVC version, threads.h availability, | |
| // and language standard. | |
| if (!(Opts.isCompatibleWithMSVC(LangOptions::MSVC2022_9) && Opts.C11)) | |
| Builder.defineMacro("__STDC_NO_THREADS__"); | |
| // Starting with VS 2022 17.1, MSVC predefines the below macro to inform | |
| // users of the execution character set defined at compile time. | |
| // The value given is the Windows Code Page Identifier: | |
| // https://docs.microsoft.com/en-us/windows/win32/intl/code-page-identifiers | |
| // | |
| // Clang currently only supports UTF-8, so we'll use 65001 | |
| Builder.defineMacro("_MSVC_EXECUTION_CHARACTER_SET", "65001"); | |
| // As of version 19.15 (VS 2017 15.8), MSVC predefines this macro to indicate | |
| // whether the traditional or standards-conforming preprocessor is in use. | |
| // Currently, MSVC compatibility mode only attempts to be compatible with the | |
| // traditional preprocessor. | |
| if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2017_8)) | |
| Builder.defineMacro("_MSVC_TRADITIONAL", "1"); | |
| } | |
| void addWindowsDefines(const llvm::Triple &Triple, const LangOptions &Opts, | |
| MacroBuilder &Builder) { | |
| Builder.defineMacro("_WIN32"); | |
| if (Triple.isArch64Bit()) | |
| Builder.defineMacro("_WIN64"); | |
| if (Triple.isWindowsGNUEnvironment()) | |
| addMinGWDefines(Triple, Opts, Builder); | |
| else if (Triple.isKnownWindowsMSVCEnvironment() || | |
| (Triple.isWindowsItaniumEnvironment() && Opts.MSVCCompat)) | |
| addVisualCDefines(Opts, Builder); | |
| } | |
| } // namespace targets | |
| } // namespace clang |