clang  16.0.0git
OSTargets.cpp
Go to the documentation of this file.
1 //===--- OSTargets.cpp - Implement OS target feature support --------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements OS specific TargetInfo types.
10 //===----------------------------------------------------------------------===//
11 
12 #include "OSTargets.h"
14 #include "llvm/ADT/StringRef.h"
15 
16 using namespace clang;
17 using namespace clang::targets;
18 
19 namespace clang {
20 namespace targets {
21 
22 void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
23  const llvm::Triple &Triple, StringRef &PlatformName,
24  VersionTuple &PlatformMinVersion) {
25  Builder.defineMacro("__APPLE_CC__", "6000");
26  Builder.defineMacro("__APPLE__");
27  Builder.defineMacro("__STDC_NO_THREADS__");
28 
29  // AddressSanitizer doesn't play well with source fortification, which is on
30  // by default on Darwin.
31  if (Opts.Sanitize.has(SanitizerKind::Address))
32  Builder.defineMacro("_FORTIFY_SOURCE", "0");
33 
34  // Darwin defines __weak, __strong, and __unsafe_unretained even in C mode.
35  if (!Opts.ObjC) {
36  // __weak is always defined, for use in blocks and with objc pointers.
37  Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
38  Builder.defineMacro("__strong", "");
39  Builder.defineMacro("__unsafe_unretained", "");
40  }
41 
42  if (Opts.Static)
43  Builder.defineMacro("__STATIC__");
44  else
45  Builder.defineMacro("__DYNAMIC__");
46 
47  if (Opts.POSIXThreads)
48  Builder.defineMacro("_REENTRANT");
49 
50  // Get the platform type and version number from the triple.
51  VersionTuple OsVersion;
52  if (Triple.isMacOSX()) {
53  Triple.getMacOSXVersion(OsVersion);
54  PlatformName = "macos";
55  } else {
56  OsVersion = Triple.getOSVersion();
57  PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
58  if (PlatformName == "ios" && Triple.isMacCatalystEnvironment())
59  PlatformName = "maccatalyst";
60  }
61 
62  // If -target arch-pc-win32-macho option specified, we're
63  // generating code for Win32 ABI. No need to emit
64  // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
65  if (PlatformName == "win32") {
66  PlatformMinVersion = OsVersion;
67  return;
68  }
69 
70  // Set the appropriate OS version define.
71  if (Triple.isiOS()) {
72  assert(OsVersion < VersionTuple(100) && "Invalid version!");
73  char Str[7];
74  if (OsVersion.getMajor() < 10) {
75  Str[0] = '0' + OsVersion.getMajor();
76  Str[1] = '0' + (OsVersion.getMinor().value_or(0) / 10);
77  Str[2] = '0' + (OsVersion.getMinor().value_or(0) % 10);
78  Str[3] = '0' + (OsVersion.getSubminor().value_or(0) / 10);
79  Str[4] = '0' + (OsVersion.getSubminor().value_or(0) % 10);
80  Str[5] = '\0';
81  } else {
82  // Handle versions >= 10.
83  Str[0] = '0' + (OsVersion.getMajor() / 10);
84  Str[1] = '0' + (OsVersion.getMajor() % 10);
85  Str[2] = '0' + (OsVersion.getMinor().value_or(0) / 10);
86  Str[3] = '0' + (OsVersion.getMinor().value_or(0) % 10);
87  Str[4] = '0' + (OsVersion.getSubminor().value_or(0) / 10);
88  Str[5] = '0' + (OsVersion.getSubminor().value_or(0) % 10);
89  Str[6] = '\0';
90  }
91  if (Triple.isTvOS())
92  Builder.defineMacro("__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__", Str);
93  else
94  Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
95  Str);
96 
97  } else if (Triple.isWatchOS()) {
98  assert(OsVersion < VersionTuple(10) && "Invalid version!");
99  char Str[6];
100  Str[0] = '0' + OsVersion.getMajor();
101  Str[1] = '0' + (OsVersion.getMinor().value_or(0) / 10);
102  Str[2] = '0' + (OsVersion.getMinor().value_or(0) % 10);
103  Str[3] = '0' + (OsVersion.getSubminor().value_or(0) / 10);
104  Str[4] = '0' + (OsVersion.getSubminor().value_or(0) % 10);
105  Str[5] = '\0';
106  Builder.defineMacro("__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str);
107  } else if (Triple.isDriverKit()) {
108  assert(OsVersion.getMajor() < 100 &&
109  OsVersion.getMinor().value_or(0) < 100 &&
110  OsVersion.getSubminor().value_or(0) < 100 && "Invalid version!");
111  char Str[7];
112  Str[0] = '0' + (OsVersion.getMajor() / 10);
113  Str[1] = '0' + (OsVersion.getMajor() % 10);
114  Str[2] = '0' + (OsVersion.getMinor().value_or(0) / 10);
115  Str[3] = '0' + (OsVersion.getMinor().value_or(0) % 10);
116  Str[4] = '0' + (OsVersion.getSubminor().value_or(0) / 10);
117  Str[5] = '0' + (OsVersion.getSubminor().value_or(0) % 10);
118  Str[6] = '\0';
119  Builder.defineMacro("__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__", Str);
120  } else if (Triple.isMacOSX()) {
121  // Note that the Driver allows versions which aren't representable in the
122  // define (because we only get a single digit for the minor and micro
123  // revision numbers). So, we limit them to the maximum representable
124  // version.
125  assert(OsVersion < VersionTuple(100) && "Invalid version!");
126  char Str[7];
127  if (OsVersion < VersionTuple(10, 10)) {
128  Str[0] = '0' + (OsVersion.getMajor() / 10);
129  Str[1] = '0' + (OsVersion.getMajor() % 10);
130  Str[2] = '0' + std::min(OsVersion.getMinor().value_or(0), 9U);
131  Str[3] = '0' + std::min(OsVersion.getSubminor().value_or(0), 9U);
132  Str[4] = '\0';
133  } else {
134  // Handle versions > 10.9.
135  Str[0] = '0' + (OsVersion.getMajor() / 10);
136  Str[1] = '0' + (OsVersion.getMajor() % 10);
137  Str[2] = '0' + (OsVersion.getMinor().value_or(0) / 10);
138  Str[3] = '0' + (OsVersion.getMinor().value_or(0) % 10);
139  Str[4] = '0' + (OsVersion.getSubminor().value_or(0) / 10);
140  Str[5] = '0' + (OsVersion.getSubminor().value_or(0) % 10);
141  Str[6] = '\0';
142  }
143  Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
144  }
145 
146  // Tell users about the kernel if there is one.
147  if (Triple.isOSDarwin())
148  Builder.defineMacro("__MACH__");
149 
150  PlatformMinVersion = OsVersion;
151 }
152 
153 static void addMinGWDefines(const llvm::Triple &Triple, const LangOptions &Opts,
154  MacroBuilder &Builder) {
155  DefineStd(Builder, "WIN32", Opts);
156  DefineStd(Builder, "WINNT", Opts);
157  if (Triple.isArch64Bit()) {
158  DefineStd(Builder, "WIN64", Opts);
159  Builder.defineMacro("__MINGW64__");
160  }
161  Builder.defineMacro("__MSVCRT__");
162  Builder.defineMacro("__MINGW32__");
163  addCygMingDefines(Opts, Builder);
164 }
165 
166 static void addVisualCDefines(const LangOptions &Opts, MacroBuilder &Builder) {
167  if (Opts.CPlusPlus) {
168  if (Opts.RTTIData)
169  Builder.defineMacro("_CPPRTTI");
170 
171  if (Opts.CXXExceptions)
172  Builder.defineMacro("_CPPUNWIND");
173  }
174 
175  if (Opts.Bool)
176  Builder.defineMacro("__BOOL_DEFINED");
177 
178  if (!Opts.CharIsSigned)
179  Builder.defineMacro("_CHAR_UNSIGNED");
180 
181  // "The /fp:contract option allows the compiler to generate floating-point
182  // contractions [...]"
183  if (Opts.getDefaultFPContractMode() != LangOptions::FPModeKind::FPM_Off)
184  Builder.defineMacro("_M_FP_CONTRACT");
185 
186  // "The /fp:except option generates code to ensures that any unmasked
187  // floating-point exceptions are raised at the exact point at which they
188  // occur, and that no other floating-point exceptions are raised."
189  if (Opts.getDefaultExceptionMode() ==
190  LangOptions::FPExceptionModeKind::FPE_Strict)
191  Builder.defineMacro("_M_FP_EXCEPT");
192 
193  // "The /fp:fast option allows the compiler to reorder, combine, or simplify
194  // floating-point operations to optimize floating-point code for speed and
195  // space. The compiler may omit rounding at assignment statements,
196  // typecasts, or function calls. It may reorder operations or make algebraic
197  // transforms, for example, by use of associative and distributive laws. It
198  // may reorder code even if such transformations result in observably
199  // different rounding behavior."
200  //
201  // "Under /fp:precise and /fp:strict, the compiler doesn't do any mathematical
202  // transformation unless the transformation is guaranteed to produce a bitwise
203  // identical result."
204  const bool any_imprecise_flags =
205  Opts.FastMath || Opts.FiniteMathOnly || Opts.UnsafeFPMath ||
206  Opts.AllowFPReassoc || Opts.NoHonorNaNs || Opts.NoHonorInfs ||
207  Opts.NoSignedZero || Opts.AllowRecip || Opts.ApproxFunc;
208 
209  // "Under both /fp:precise and /fp:fast, the compiler generates code intended
210  // to run in the default floating-point environment."
211  //
212  // "[The] default floating point environment [...] sets the rounding mode
213  // to round to nearest."
214  if (Opts.getDefaultRoundingMode() ==
215  LangOptions::RoundingMode::NearestTiesToEven) {
216  if (any_imprecise_flags) {
217  Builder.defineMacro("_M_FP_FAST");
218  } else {
219  Builder.defineMacro("_M_FP_PRECISE");
220  }
221  } else if (!any_imprecise_flags && Opts.getDefaultRoundingMode() ==
222  LangOptions::RoundingMode::Dynamic) {
223  // "Under /fp:strict, the compiler generates code that allows the
224  // program to safely unmask floating-point exceptions, read or write
225  // floating-point status registers, or change rounding modes."
226  Builder.defineMacro("_M_FP_STRICT");
227  }
228 
229  // FIXME: POSIXThreads isn't exactly the option this should be defined for,
230  // but it works for now.
231  if (Opts.POSIXThreads)
232  Builder.defineMacro("_MT");
233 
234  if (Opts.MSCompatibilityVersion) {
235  Builder.defineMacro("_MSC_VER",
236  Twine(Opts.MSCompatibilityVersion / 100000));
237  Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
238  // FIXME We cannot encode the revision information into 32-bits
239  Builder.defineMacro("_MSC_BUILD", Twine(1));
240 
241  if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
242  Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
243 
245  if (Opts.CPlusPlus2b)
246  Builder.defineMacro("_MSVC_LANG", "202004L");
247  else if (Opts.CPlusPlus20)
248  Builder.defineMacro("_MSVC_LANG", "202002L");
249  else if (Opts.CPlusPlus17)
250  Builder.defineMacro("_MSVC_LANG", "201703L");
251  else if (Opts.CPlusPlus14)
252  Builder.defineMacro("_MSVC_LANG", "201402L");
253  }
254  }
255 
256  if (Opts.MicrosoftExt) {
257  Builder.defineMacro("_MSC_EXTENSIONS");
258 
259  if (Opts.CPlusPlus11) {
260  Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
261  Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
262  Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
263  }
264  }
265 
266  if (!Opts.MSVolatile)
267  Builder.defineMacro("_ISO_VOLATILE");
268 
269  if (Opts.Kernel)
270  Builder.defineMacro("_KERNEL_MODE");
271 
272  Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
273  Builder.defineMacro("__STDC_NO_THREADS__");
274 
275  // Starting with VS 2022 17.1, MSVC predefines the below macro to inform
276  // users of the execution character set defined at compile time.
277  // The value given is the Windows Code Page Identifier:
278  // https://docs.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
279  //
280  // Clang currently only supports UTF-8, so we'll use 65001
281  Builder.defineMacro("_MSVC_EXECUTION_CHARACTER_SET", "65001");
282 }
283 
284 void addWindowsDefines(const llvm::Triple &Triple, const LangOptions &Opts,
285  MacroBuilder &Builder) {
286  Builder.defineMacro("_WIN32");
287  if (Triple.isArch64Bit())
288  Builder.defineMacro("_WIN64");
289  if (Triple.isWindowsGNUEnvironment())
290  addMinGWDefines(Triple, Opts, Builder);
291  else if (Triple.isKnownWindowsMSVCEnvironment() ||
292  (Triple.isWindowsItaniumEnvironment() && Opts.MSVCCompat))
293  addVisualCDefines(Opts, Builder);
294 }
295 
296 } // namespace targets
297 } // namespace clang
clang::SanitizerSet::has
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:155
clang::LangOptions::getDefaultRoundingMode
RoundingMode getDefaultRoundingMode() const
Definition: LangOptions.h:639
clang::targets::getDarwinDefines
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, const llvm::Triple &Triple, StringRef &PlatformName, VersionTuple &PlatformMinVersion)
Definition: OSTargets.cpp:22
clang::targets::addCygMingDefines
void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder)
Definition: Targets.cpp:82
U
clang::LangOptions::isCompatibleWithMSVC
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:539
min
__DEVICE__ int min(int __a, int __b)
Definition: __clang_cuda_math.h:197
MacroBuilder.h
clang::targets::DefineStd
void DefineStd(MacroBuilder &Builder, StringRef MacroName, const LangOptions &Opts)
DefineStd - Define a macro name and standard variants.
Definition: Targets.cpp:59
clang::LangOptions::getDefaultExceptionMode
FPExceptionModeKind getDefaultExceptionMode() const
Definition: LangOptions.h:644
clang::LangOptions::Sanitize
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:385
clang::targets::addMinGWDefines
static void addMinGWDefines(const llvm::Triple &Triple, const LangOptions &Opts, MacroBuilder &Builder)
Definition: OSTargets.cpp:153
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:81
clang
Definition: CalledOnceCheck.h:17
clang::LangOptions::MSVC2015
@ MSVC2015
Definition: LangOptions.h:145
clang::targets
Definition: AArch64.h:21
OSTargets.h
clang::targets::addVisualCDefines
static void addVisualCDefines(const LangOptions &Opts, MacroBuilder &Builder)
Definition: OSTargets.cpp:166
clang::targets::addWindowsDefines
void addWindowsDefines(const llvm::Triple &Triple, const LangOptions &Opts, MacroBuilder &Builder)
Definition: OSTargets.cpp:284
clang::MacroBuilder
Definition: MacroBuilder.h:23