mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-27 21:06:06 +00:00
6abe19ac58
This patch makes Clang predefine `_CRT_USE_BUILTIN_OFFSETOF` in MS-compatible modes. The macro can make the `offsetof` provided by MS UCRT's `<stddef.h>` to select the `__builtin_offsetof` version, so with it Clang (Clang-cl) can directly consume UCRT's `offsetof`. MSVC predefines the macro as `1` since at least VS 2017 19.14, but I think it's also OK to define it in "older" compatible modes. Fixes #59689.
291 lines
11 KiB
C++
291 lines
11 KiB
C++
//===--- 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 "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");
|
|
}
|
|
|
|
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
|