1//===--- OSTargets.h - Declare OS target feature support --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares OS specific TargetInfo types.
10//===----------------------------------------------------------------------===//
11
12#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
13#define LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
14
15#include "Targets.h"
16
17namespace clang {
18namespace targets {
19
20template <typename TgtInfo>
21class LLVM_LIBRARY_VISIBILITY OSTargetInfo : public TgtInfo {
22protected:
23 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
24 MacroBuilder &Builder) const = 0;
25
26public:
27 OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
28 : TgtInfo(Triple, Opts) {}
29
30 void getTargetDefines(const LangOptions &Opts,
31 MacroBuilder &Builder) const override {
32 TgtInfo::getTargetDefines(Opts, Builder);
33 getOSDefines(Opts, Triple: TgtInfo::getTriple(), Builder);
34 }
35};
36
37void getAppleMachODefines(MacroBuilder &Builder, const LangOptions &Opts,
38 const llvm::Triple &Triple);
39
40void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
41 const llvm::Triple &Triple, StringRef &PlatformName,
42 VersionTuple &PlatformMinVersion);
43
44template <typename Target>
45class LLVM_LIBRARY_VISIBILITY AppleMachOTargetInfo
46 : public OSTargetInfo<Target> {
47protected:
48 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
49 MacroBuilder &Builder) const override {
50 getAppleMachODefines(Builder, Opts, Triple);
51 }
52
53public:
54 AppleMachOTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
55 : OSTargetInfo<Target>(Triple, Opts) {}
56
57 const char *getStaticInitSectionSpecifier() const override {
58 return "__TEXT,__StaticInit,regular,pure_instructions";
59 }
60
61 /// Apple Mach-O does not support protected visibility. Its "default" is very
62 /// similar to ELF's "protected"; Apple Mach-O requires a "weak" attribute on
63 /// declarations that can be dynamically replaced.
64 bool hasProtectedVisibility() const override { return false; }
65};
66
67template <typename Target>
68class LLVM_LIBRARY_VISIBILITY DarwinTargetInfo
69 : public AppleMachOTargetInfo<Target> {
70protected:
71 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
72 MacroBuilder &Builder) const override {
73 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
74 this->PlatformMinVersion);
75 }
76
77public:
78 DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
79 : AppleMachOTargetInfo<Target>(Triple, Opts) {
80 // By default, no TLS, and we list permitted architecture/OS
81 // combinations.
82 this->TLSSupported = false;
83
84 if (Triple.isMacOSX())
85 this->TLSSupported = !Triple.isMacOSXVersionLT(Major: 10, Minor: 7);
86 else if (Triple.isiOS()) {
87 // 64-bit iOS supported it from 8 onwards, 32-bit device from 9 onwards,
88 // 32-bit simulator from 10 onwards.
89 if (Triple.isArch64Bit())
90 this->TLSSupported = !Triple.isOSVersionLT(Major: 8);
91 else if (Triple.isArch32Bit()) {
92 if (!Triple.isSimulatorEnvironment())
93 this->TLSSupported = !Triple.isOSVersionLT(Major: 9);
94 else
95 this->TLSSupported = !Triple.isOSVersionLT(Major: 10);
96 }
97 } else if (Triple.isWatchOS()) {
98 if (!Triple.isSimulatorEnvironment())
99 this->TLSSupported = !Triple.isOSVersionLT(Major: 2);
100 else
101 this->TLSSupported = !Triple.isOSVersionLT(Major: 3);
102 } else if (Triple.isDriverKit()) {
103 // No TLS on DriverKit.
104 } else if (Triple.isXROS())
105 this->TLSSupported = true;
106
107 this->MCountName = "\01mcount";
108 }
109
110 const char *getStaticInitSectionSpecifier() const override {
111 // FIXME: We should return 0 when building kexts.
112 return AppleMachOTargetInfo<Target>::getStaticInitSectionSpecifier();
113 }
114
115 unsigned getExnObjectAlignment() const override {
116 // Older versions of libc++abi guarantee an alignment of only 8-bytes for
117 // exception objects because of a bug in __cxa_exception that was
118 // eventually fixed in r319123.
119 llvm::VersionTuple MinVersion;
120 const llvm::Triple &T = this->getTriple();
121
122 // Compute the earliest OS versions that have the fix to libc++abi.
123 switch (T.getOS()) {
124 case llvm::Triple::Darwin:
125 case llvm::Triple::MacOSX: // Earliest supporting version is 10.14.
126 MinVersion = llvm::VersionTuple(10U, 14U);
127 break;
128 case llvm::Triple::IOS:
129 case llvm::Triple::TvOS: // Earliest supporting version is 12.0.0.
130 MinVersion = llvm::VersionTuple(12U);
131 break;
132 case llvm::Triple::WatchOS: // Earliest supporting version is 5.0.0.
133 MinVersion = llvm::VersionTuple(5U);
134 break;
135 case llvm::Triple::XROS:
136 MinVersion = llvm::VersionTuple(0);
137 break;
138 default:
139 // Conservatively return 8 bytes if OS is unknown.
140 return 64;
141 }
142
143 if (T.getOSVersion() < MinVersion)
144 return 64;
145 return OSTargetInfo<Target>::getExnObjectAlignment();
146 }
147
148 TargetInfo::IntType getLeastIntTypeByWidth(unsigned BitWidth,
149 bool IsSigned) const final {
150 // Darwin uses `long long` for `int_least64_t` and `int_fast64_t`.
151 return BitWidth == 64
152 ? (IsSigned ? TargetInfo::SignedLongLong
153 : TargetInfo::UnsignedLongLong)
154 : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
155 }
156
157 bool areDefaultedSMFStillPOD(const LangOptions &) const override {
158 return false;
159 }
160};
161
162// DragonFlyBSD Target
163template <typename Target>
164class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo
165 : public OSTargetInfo<Target> {
166protected:
167 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
168 MacroBuilder &Builder) const override {
169 // DragonFly defines; list based off of gcc output
170 Builder.defineMacro(Name: "__DragonFly__");
171 Builder.defineMacro(Name: "__DragonFly_cc_version", Value: "100001");
172 Builder.defineMacro(Name: "__KPRINTF_ATTRIBUTE__");
173 Builder.defineMacro(Name: "__tune_i386__");
174 DefineStd(Builder, MacroName: "unix", Opts);
175 if (this->HasFloat128)
176 Builder.defineMacro(Name: "__FLOAT128__");
177
178 if (Opts.C11)
179 Builder.defineMacro(Name: "__STDC_NO_THREADS__");
180 }
181
182public:
183 DragonFlyBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
184 : OSTargetInfo<Target>(Triple, Opts) {
185 switch (Triple.getArch()) {
186 default:
187 case llvm::Triple::x86:
188 case llvm::Triple::x86_64:
189 this->HasFloat128 = true;
190 this->MCountName = ".mcount";
191 break;
192 }
193 }
194};
195
196#ifndef FREEBSD_CC_VERSION
197#define FREEBSD_CC_VERSION 0U
198#endif
199
200// FreeBSD Target
201template <typename Target>
202class LLVM_LIBRARY_VISIBILITY FreeBSDTargetInfo : public OSTargetInfo<Target> {
203protected:
204 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
205 MacroBuilder &Builder) const override {
206 // FreeBSD defines; list based off of gcc output
207
208 unsigned Release = Triple.getOSMajorVersion();
209 if (Release == 0U)
210 Release = 8U;
211 unsigned CCVersion = FREEBSD_CC_VERSION;
212 if (CCVersion == 0U)
213 CCVersion = Release * 100000U + 1U;
214
215 Builder.defineMacro(Name: "__FreeBSD__", Value: Twine(Release));
216 Builder.defineMacro(Name: "__FreeBSD_cc_version", Value: Twine(CCVersion));
217 Builder.defineMacro(Name: "__KPRINTF_ATTRIBUTE__");
218 DefineStd(Builder, MacroName: "unix", Opts);
219 if (this->HasFloat128)
220 Builder.defineMacro(Name: "__FLOAT128__");
221
222 // On FreeBSD, wchar_t contains the number of the code point as
223 // used by the character set of the locale. These character sets are
224 // not necessarily a superset of ASCII.
225 //
226 // FIXME: This is wrong; the macro refers to the numerical values
227 // of wchar_t *literals*, which are not locale-dependent. However,
228 // FreeBSD systems apparently depend on us getting this wrong, and
229 // setting this to 1 is conforming even if all the basic source
230 // character literals have the same encoding as char and wchar_t.
231 Builder.defineMacro(Name: "__STDC_MB_MIGHT_NEQ_WC__", Value: "1");
232 }
233
234public:
235 FreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
236 : OSTargetInfo<Target>(Triple, Opts) {
237 switch (Triple.getArch()) {
238 case llvm::Triple::x86:
239 case llvm::Triple::x86_64:
240 this->HasFloat128 = true;
241 [[fallthrough]];
242 default:
243 this->MCountName = ".mcount";
244 break;
245 case llvm::Triple::mips:
246 case llvm::Triple::mipsel:
247 case llvm::Triple::ppc:
248 case llvm::Triple::ppcle:
249 case llvm::Triple::ppc64:
250 case llvm::Triple::ppc64le:
251 this->MCountName = "_mcount";
252 break;
253 case llvm::Triple::arm:
254 this->MCountName = "__mcount";
255 break;
256 case llvm::Triple::loongarch64:
257 case llvm::Triple::riscv64:
258 break;
259 }
260 }
261};
262
263// GNU/kFreeBSD Target
264template <typename Target>
265class LLVM_LIBRARY_VISIBILITY KFreeBSDTargetInfo : public OSTargetInfo<Target> {
266protected:
267 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
268 MacroBuilder &Builder) const override {
269 // GNU/kFreeBSD defines; list based off of gcc output
270
271 DefineStd(Builder, MacroName: "unix", Opts);
272 Builder.defineMacro(Name: "__FreeBSD_kernel__");
273 Builder.defineMacro(Name: "__GLIBC__");
274 if (Opts.POSIXThreads)
275 Builder.defineMacro(Name: "_REENTRANT");
276 if (Opts.CPlusPlus)
277 Builder.defineMacro(Name: "_GNU_SOURCE");
278 }
279
280public:
281 using OSTargetInfo<Target>::OSTargetInfo;
282};
283
284// Haiku Target
285template <typename Target>
286class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> {
287protected:
288 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
289 MacroBuilder &Builder) const override {
290 // Haiku defines; list based off of gcc output
291 Builder.defineMacro(Name: "__HAIKU__");
292 DefineStd(Builder, MacroName: "unix", Opts);
293 if (this->HasFloat128)
294 Builder.defineMacro(Name: "__FLOAT128__");
295 }
296
297public:
298 HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
299 : OSTargetInfo<Target>(Triple, Opts) {
300 this->SizeType = TargetInfo::UnsignedLong;
301 this->IntPtrType = TargetInfo::SignedLong;
302 this->PtrDiffType = TargetInfo::SignedLong;
303 this->ProcessIDType = TargetInfo::SignedLong;
304 switch (Triple.getArch()) {
305 default:
306 break;
307 case llvm::Triple::x86:
308 case llvm::Triple::x86_64:
309 this->HasFloat128 = true;
310 break;
311 }
312 }
313};
314
315// Hurd target
316template <typename Target>
317class LLVM_LIBRARY_VISIBILITY HurdTargetInfo : public OSTargetInfo<Target> {
318protected:
319 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
320 MacroBuilder &Builder) const override {
321 // Hurd defines; list based off of gcc output.
322 DefineStd(Builder, MacroName: "unix", Opts);
323 Builder.defineMacro(Name: "__GNU__");
324 Builder.defineMacro(Name: "__gnu_hurd__");
325 Builder.defineMacro(Name: "__MACH__");
326 Builder.defineMacro(Name: "__GLIBC__");
327 if (Opts.POSIXThreads)
328 Builder.defineMacro(Name: "_REENTRANT");
329 if (Opts.CPlusPlus)
330 Builder.defineMacro(Name: "_GNU_SOURCE");
331 }
332public:
333 using OSTargetInfo<Target>::OSTargetInfo;
334};
335
336// Linux target
337template <typename Target>
338class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {
339protected:
340 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
341 MacroBuilder &Builder) const override {
342 // Linux defines; list based off of gcc output
343 DefineStd(Builder, MacroName: "unix", Opts);
344 DefineStd(Builder, MacroName: "linux", Opts);
345 if (Triple.isAndroid()) {
346 Builder.defineMacro(Name: "__ANDROID__", Value: "1");
347 this->PlatformName = "android";
348 this->PlatformMinVersion = Triple.getEnvironmentVersion();
349 const unsigned Maj = this->PlatformMinVersion.getMajor();
350 if (Maj) {
351 Builder.defineMacro(Name: "__ANDROID_MIN_SDK_VERSION__", Value: Twine(Maj));
352 // This historical but ambiguous name for the minSdkVersion macro. Keep
353 // defined for compatibility.
354 Builder.defineMacro(Name: "__ANDROID_API__", Value: "__ANDROID_MIN_SDK_VERSION__");
355 }
356 } else {
357 Builder.defineMacro(Name: "__gnu_linux__");
358 }
359 if (Opts.POSIXThreads)
360 Builder.defineMacro(Name: "_REENTRANT");
361 if (Opts.CPlusPlus)
362 Builder.defineMacro(Name: "_GNU_SOURCE");
363 if (this->HasFloat128)
364 Builder.defineMacro(Name: "__FLOAT128__");
365 if (Triple.isTime64ABI()) {
366 Builder.defineMacro(Name: "_FILE_OFFSET_BITS", Value: "64");
367 Builder.defineMacro(Name: "_TIME_BITS", Value: "64");
368 }
369 }
370
371public:
372 LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
373 : OSTargetInfo<Target>(Triple, Opts) {
374 this->WIntType = TargetInfo::UnsignedInt;
375
376 switch (Triple.getArch()) {
377 default:
378 break;
379 case llvm::Triple::mips:
380 case llvm::Triple::mipsel:
381 case llvm::Triple::mips64:
382 case llvm::Triple::mips64el:
383 case llvm::Triple::ppc:
384 case llvm::Triple::ppcle:
385 case llvm::Triple::ppc64:
386 case llvm::Triple::ppc64le:
387 this->MCountName = "_mcount";
388 break;
389 case llvm::Triple::x86:
390 case llvm::Triple::x86_64:
391 this->HasFloat128 = true;
392 break;
393 }
394 }
395
396 const char *getStaticInitSectionSpecifier() const override {
397 return ".text.startup";
398 }
399};
400
401// Managarm Target
402template <typename Target>
403class LLVM_LIBRARY_VISIBILITY ManagarmTargetInfo : public OSTargetInfo<Target> {
404protected:
405 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
406 MacroBuilder &Builder) const override {
407 DefineStd(Builder, MacroName: "unix", Opts);
408 Builder.defineMacro(Name: "__managarm__");
409 if (Opts.POSIXThreads)
410 Builder.defineMacro(Name: "_REENTRANT");
411 if (Opts.CPlusPlus)
412 Builder.defineMacro(Name: "_GNU_SOURCE");
413 if (this->HasFloat128)
414 Builder.defineMacro(Name: "__FLOAT128__");
415 }
416
417public:
418 ManagarmTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
419 : OSTargetInfo<Target>(Triple, Opts) {
420 switch (Triple.getArch()) {
421 default:
422 break;
423 case llvm::Triple::x86:
424 case llvm::Triple::x86_64:
425 this->HasFloat128 = true;
426 break;
427 }
428 }
429};
430
431// NetBSD Target
432template <typename Target>
433class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> {
434protected:
435 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
436 MacroBuilder &Builder) const override {
437 // NetBSD defines; list based off of gcc output
438 Builder.defineMacro(Name: "__NetBSD__");
439 Builder.defineMacro(Name: "__unix__");
440 if (Opts.POSIXThreads)
441 Builder.defineMacro(Name: "_REENTRANT");
442 if (this->HasFloat128)
443 Builder.defineMacro(Name: "__FLOAT128__");
444 }
445
446public:
447 NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
448 : OSTargetInfo<Target>(Triple, Opts) {
449 this->MCountName = "__mcount";
450 switch (Triple.getArch()) {
451 default:
452 break;
453 case llvm::Triple::x86:
454 case llvm::Triple::x86_64:
455 this->HasFloat128 = true;
456 break;
457 }
458 }
459};
460
461// OpenBSD Target
462template <typename Target>
463class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> {
464protected:
465 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
466 MacroBuilder &Builder) const override {
467 // OpenBSD defines; list based off of gcc output
468
469 Builder.defineMacro(Name: "__OpenBSD__");
470 DefineStd(Builder, MacroName: "unix", Opts);
471 if (Opts.POSIXThreads)
472 Builder.defineMacro(Name: "_REENTRANT");
473 if (this->HasFloat128)
474 Builder.defineMacro(Name: "__FLOAT128__");
475
476 if (Opts.C11)
477 Builder.defineMacro(Name: "__STDC_NO_THREADS__");
478 }
479
480public:
481 OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
482 : OSTargetInfo<Target>(Triple, Opts) {
483 this->WCharType = this->WIntType = this->SignedInt;
484 this->IntMaxType = TargetInfo::SignedLongLong;
485 this->Int64Type = TargetInfo::SignedLongLong;
486 switch (Triple.getArch()) {
487 case llvm::Triple::x86:
488 case llvm::Triple::x86_64:
489 this->HasFloat128 = true;
490 [[fallthrough]];
491 default:
492 this->MCountName = "__mcount";
493 break;
494 case llvm::Triple::mips64:
495 case llvm::Triple::mips64el:
496 case llvm::Triple::ppc:
497 case llvm::Triple::ppc64:
498 case llvm::Triple::ppc64le:
499 case llvm::Triple::sparcv9:
500 this->MCountName = "_mcount";
501 break;
502 case llvm::Triple::loongarch64:
503 case llvm::Triple::riscv64:
504 break;
505 }
506 }
507};
508
509// PS3 PPU Target
510template <typename Target>
511class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> {
512protected:
513 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
514 MacroBuilder &Builder) const override {
515 // PS3 PPU defines.
516 Builder.defineMacro(Name: "__PPU__");
517 Builder.defineMacro(Name: "__CELLOS_LV2__");
518 Builder.defineMacro(Name: "__LP32__");
519 Builder.defineMacro(Name: "_ARCH_PPC64");
520 Builder.defineMacro(Name: "__powerpc64__");
521 }
522
523public:
524 PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
525 : OSTargetInfo<Target>(Triple, Opts) {
526 this->LongWidth = this->LongAlign = 32;
527 this->PointerWidth = this->PointerAlign = 32;
528 this->IntMaxType = TargetInfo::SignedLongLong;
529 this->Int64Type = TargetInfo::SignedLongLong;
530 this->SizeType = TargetInfo::UnsignedInt;
531 this->resetDataLayout("E-m:e-p:32:32-Fi64-i64:64-i128:128-n32:64");
532 }
533};
534
535// Common base class for PS4/PS5 targets.
536template <typename Target>
537class LLVM_LIBRARY_VISIBILITY PSOSTargetInfo : public OSTargetInfo<Target> {
538protected:
539 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
540 MacroBuilder &Builder) const override {
541 Builder.defineMacro(Name: "__FreeBSD__", Value: "9");
542 Builder.defineMacro(Name: "__FreeBSD_cc_version", Value: "900001");
543 Builder.defineMacro(Name: "__KPRINTF_ATTRIBUTE__");
544 DefineStd(Builder, MacroName: "unix", Opts);
545 Builder.defineMacro(Name: "__SCE__");
546 Builder.defineMacro(Name: "__STDC_NO_COMPLEX__");
547 Builder.defineMacro(Name: "__STDC_NO_THREADS__");
548 }
549
550public:
551 PSOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
552 : OSTargetInfo<Target>(Triple, Opts) {
553 this->WCharType = TargetInfo::UnsignedShort;
554
555 // On PS4/PS5, TLS variable cannot be aligned to more than 32 bytes (256
556 // bits).
557 this->MaxTLSAlign = 256;
558
559 // On PS4/PS5, do not honor explicit bit field alignment,
560 // as in "__attribute__((aligned(2))) int b : 1;".
561 this->UseExplicitBitFieldAlignment = false;
562
563 this->MCountName = ".mcount";
564 this->NewAlign = 256;
565 this->SuitableAlign = 256;
566 }
567
568 TargetInfo::CallingConvCheckResult
569 checkCallingConvention(CallingConv CC) const override {
570 return (CC == CC_C) ? TargetInfo::CCCR_OK : TargetInfo::CCCR_Error;
571 }
572
573 bool areDefaultedSMFStillPOD(const LangOptions &) const override {
574 return false;
575 }
576};
577
578// PS4 Target
579template <typename Target>
580class LLVM_LIBRARY_VISIBILITY PS4OSTargetInfo : public PSOSTargetInfo<Target> {
581protected:
582 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
583 MacroBuilder &Builder) const override {
584 // Start with base class defines.
585 PSOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);
586
587 Builder.defineMacro(Name: "__ORBIS__");
588 }
589
590public:
591 using PSOSTargetInfo<Target>::PSOSTargetInfo;
592};
593
594// PS5 Target
595template <typename Target>
596class LLVM_LIBRARY_VISIBILITY PS5OSTargetInfo : public PSOSTargetInfo<Target> {
597protected:
598 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
599 MacroBuilder &Builder) const override {
600 // Start with base class defines.
601 PSOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);
602
603 Builder.defineMacro(Name: "__PROSPERO__");
604 }
605
606public:
607 using PSOSTargetInfo<Target>::PSOSTargetInfo;
608};
609
610// RTEMS Target
611template <typename Target>
612class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> {
613protected:
614 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
615 MacroBuilder &Builder) const override {
616 // RTEMS defines; list based off of gcc output
617
618 Builder.defineMacro(Name: "__rtems__");
619 if (Opts.CPlusPlus)
620 Builder.defineMacro(Name: "_GNU_SOURCE");
621 }
622
623public:
624 RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
625 : OSTargetInfo<Target>(Triple, Opts) {
626 switch (Triple.getArch()) {
627 default:
628 case llvm::Triple::x86:
629 // this->MCountName = ".mcount";
630 break;
631 case llvm::Triple::mips:
632 case llvm::Triple::mipsel:
633 case llvm::Triple::ppc:
634 case llvm::Triple::ppc64:
635 case llvm::Triple::ppc64le:
636 // this->MCountName = "_mcount";
637 break;
638 case llvm::Triple::arm:
639 // this->MCountName = "__mcount";
640 break;
641 }
642 }
643};
644
645// Solaris target
646template <typename Target>
647class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> {
648protected:
649 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
650 MacroBuilder &Builder) const override {
651 DefineStd(Builder, MacroName: "sun", Opts);
652 DefineStd(Builder, MacroName: "unix", Opts);
653 Builder.defineMacro(Name: "__svr4__");
654 Builder.defineMacro(Name: "__SVR4");
655 Builder.defineMacro(Name: "_XOPEN_SOURCE", Value: "600");
656 if (Opts.CPlusPlus) {
657 Builder.defineMacro(Name: "__C99FEATURES__");
658 Builder.defineMacro(Name: "_FILE_OFFSET_BITS", Value: "64");
659 }
660 // GCC restricts the next two to C++.
661 Builder.defineMacro(Name: "_LARGEFILE_SOURCE");
662 Builder.defineMacro(Name: "_LARGEFILE64_SOURCE");
663 Builder.defineMacro(Name: "__EXTENSIONS__");
664 if (Opts.POSIXThreads)
665 Builder.defineMacro(Name: "_REENTRANT");
666 if (this->HasFloat128)
667 Builder.defineMacro(Name: "__FLOAT128__");
668 }
669
670public:
671 SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
672 : OSTargetInfo<Target>(Triple, Opts) {
673 if (this->PointerWidth == 64) {
674 this->WCharType = this->WIntType = this->SignedInt;
675 } else {
676 this->WCharType = this->WIntType = this->SignedLong;
677 }
678 switch (Triple.getArch()) {
679 default:
680 break;
681 case llvm::Triple::x86:
682 case llvm::Triple::x86_64:
683 this->HasFloat128 = true;
684 break;
685 }
686 }
687};
688
689// AIX Target
690template <typename Target>
691class AIXTargetInfo : public OSTargetInfo<Target> {
692protected:
693 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
694 MacroBuilder &Builder) const override {
695 DefineStd(Builder, MacroName: "unix", Opts);
696 Builder.defineMacro(Name: "_IBMR2");
697 Builder.defineMacro(Name: "_POWER");
698 Builder.defineMacro(Name: "__THW_BIG_ENDIAN__");
699
700 Builder.defineMacro(Name: "_AIX");
701 Builder.defineMacro(Name: "__TOS_AIX__");
702 Builder.defineMacro(Name: "__HOS_AIX__");
703
704 if (Opts.C11) {
705 Builder.defineMacro(Name: "__STDC_NO_ATOMICS__");
706 Builder.defineMacro(Name: "__STDC_NO_THREADS__");
707 }
708
709 if (Opts.EnableAIXExtendedAltivecABI)
710 Builder.defineMacro(Name: "__EXTABI__");
711
712 VersionTuple OsVersion = Triple.getOSVersion();
713
714 // Define AIX OS-Version Macros.
715 // Includes logic for legacy versions of AIX; no specific intent to support.
716 if (OsVersion >= VersionTuple(3, 2))
717 Builder.defineMacro(Name: "_AIX32");
718 if (OsVersion >= VersionTuple(4, 1))
719 Builder.defineMacro(Name: "_AIX41");
720 if (OsVersion >= VersionTuple(4, 3))
721 Builder.defineMacro(Name: "_AIX43");
722 if (OsVersion >= VersionTuple(5, 0))
723 Builder.defineMacro(Name: "_AIX50");
724 if (OsVersion >= VersionTuple(5, 1))
725 Builder.defineMacro(Name: "_AIX51");
726 if (OsVersion >= VersionTuple(5, 2))
727 Builder.defineMacro(Name: "_AIX52");
728 if (OsVersion >= VersionTuple(5, 3))
729 Builder.defineMacro(Name: "_AIX53");
730 if (OsVersion >= VersionTuple(6, 1))
731 Builder.defineMacro(Name: "_AIX61");
732 if (OsVersion >= VersionTuple(7, 1))
733 Builder.defineMacro(Name: "_AIX71");
734 if (OsVersion >= VersionTuple(7, 2))
735 Builder.defineMacro(Name: "_AIX72");
736 if (OsVersion >= VersionTuple(7, 3))
737 Builder.defineMacro(Name: "_AIX73");
738
739 // FIXME: Do not define _LONG_LONG when -fno-long-long is specified.
740 Builder.defineMacro(Name: "_LONG_LONG");
741
742 if (Opts.POSIXThreads) {
743 Builder.defineMacro(Name: "_THREAD_SAFE");
744 }
745
746 if (this->PointerWidth == 64) {
747 Builder.defineMacro(Name: "__64BIT__");
748 }
749
750 // Define _WCHAR_T when it is a fundamental type
751 // (i.e., for C++ without -fno-wchar).
752 if (Opts.CPlusPlus && Opts.WChar) {
753 Builder.defineMacro(Name: "_WCHAR_T");
754 }
755 }
756
757public:
758 AIXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
759 : OSTargetInfo<Target>(Triple, Opts) {
760 this->MCountName = "__mcount";
761 this->TheCXXABI.set(TargetCXXABI::XL);
762
763 if (this->PointerWidth == 64) {
764 this->WCharType = this->UnsignedInt;
765 } else {
766 this->WCharType = this->UnsignedShort;
767 }
768 this->UseZeroLengthBitfieldAlignment = true;
769 }
770
771 // AIX sets FLT_EVAL_METHOD to be 1.
772 LangOptions::FPEvalMethodKind getFPEvalMethod() const override {
773 return LangOptions::FPEvalMethodKind::FEM_Double;
774 }
775
776 bool defaultsToAIXPowerAlignment() const override { return true; }
777
778 bool areDefaultedSMFStillPOD(const LangOptions &) const override {
779 return false;
780 }
781};
782
783// z/OS target
784template <typename Target>
785class LLVM_LIBRARY_VISIBILITY ZOSTargetInfo : public OSTargetInfo<Target> {
786protected:
787 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
788 MacroBuilder &Builder) const override {
789 // FIXME: _LONG_LONG should not be defined under -std=c89.
790 Builder.defineMacro(Name: "_LONG_LONG");
791 Builder.defineMacro(Name: "__370__");
792 Builder.defineMacro(Name: "__BFP__");
793 // FIXME: __BOOL__ should not be defined under -std=c89.
794 Builder.defineMacro(Name: "__BOOL__");
795 Builder.defineMacro(Name: "__COMPILER_VER__", Value: "0x50000000");
796 Builder.defineMacro(Name: "__LONGNAME__");
797 Builder.defineMacro(Name: "__MVS__");
798 Builder.defineMacro(Name: "__THW_370__");
799 Builder.defineMacro(Name: "__THW_BIG_ENDIAN__");
800 Builder.defineMacro(Name: "__TOS_390__");
801 Builder.defineMacro(Name: "__TOS_MVS__");
802 Builder.defineMacro(Name: "__XPLINK__");
803
804 if (this->PointerWidth == 64)
805 Builder.defineMacro(Name: "__64BIT__");
806
807 if (Opts.CPlusPlus && Opts.WChar) {
808 // Macro __wchar_t is defined so that the wchar_t data
809 // type is not declared as a typedef in system headers.
810 Builder.defineMacro(Name: "__wchar_t");
811 }
812
813 this->PlatformName = llvm::Triple::getOSTypeName(Kind: Triple.getOS());
814 }
815
816public:
817 ZOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
818 : OSTargetInfo<Target>(Triple, Opts) {
819 this->WCharType = TargetInfo::UnsignedInt;
820 this->MaxAlignedAttribute = 128;
821 this->UseBitFieldTypeAlignment = false;
822 this->UseZeroLengthBitfieldAlignment = true;
823 this->UseLeadingZeroLengthBitfield = false;
824 this->ZeroLengthBitfieldBoundary = 32;
825 this->TheCXXABI.set(TargetCXXABI::XL);
826 }
827
828 bool areDefaultedSMFStillPOD(const LangOptions &) const override {
829 return false;
830 }
831};
832
833// UEFI target
834template <typename Target>
835class LLVM_LIBRARY_VISIBILITY UEFITargetInfo : public OSTargetInfo<Target> {
836protected:
837 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
838 MacroBuilder &Builder) const override {
839 Builder.defineMacro(Name: "__UEFI__");
840 }
841
842public:
843 UEFITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
844 : OSTargetInfo<Target>(Triple, Opts) {
845 this->WCharType = TargetInfo::UnsignedShort;
846 this->WIntType = TargetInfo::UnsignedShort;
847 this->UseMicrosoftManglingForC = true;
848 }
849};
850
851void addWindowsDefines(const llvm::Triple &Triple, const LangOptions &Opts,
852 MacroBuilder &Builder);
853
854// Windows target
855template <typename Target>
856class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> {
857protected:
858 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
859 MacroBuilder &Builder) const override {
860 addWindowsDefines(Triple, Opts, Builder);
861 }
862
863public:
864 WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
865 : OSTargetInfo<Target>(Triple, Opts) {
866 this->WCharType = TargetInfo::UnsignedShort;
867 this->WIntType = TargetInfo::UnsignedShort;
868 this->UseMicrosoftManglingForC = true;
869 }
870};
871
872template <typename Target>
873class LLVM_LIBRARY_VISIBILITY NaClTargetInfo : public OSTargetInfo<Target> {
874protected:
875 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
876 MacroBuilder &Builder) const override {
877 if (Opts.POSIXThreads)
878 Builder.defineMacro(Name: "_REENTRANT");
879 if (Opts.CPlusPlus)
880 Builder.defineMacro(Name: "_GNU_SOURCE");
881
882 DefineStd(Builder, MacroName: "unix", Opts);
883 Builder.defineMacro(Name: "__native_client__");
884 }
885
886public:
887 NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
888 : OSTargetInfo<Target>(Triple, Opts) {
889 this->LongAlign = 32;
890 this->LongWidth = 32;
891 this->PointerAlign = 32;
892 this->PointerWidth = 32;
893 this->IntMaxType = TargetInfo::SignedLongLong;
894 this->Int64Type = TargetInfo::SignedLongLong;
895 this->DoubleAlign = 64;
896 this->LongDoubleWidth = 64;
897 this->LongDoubleAlign = 64;
898 this->LongLongWidth = 64;
899 this->LongLongAlign = 64;
900 this->SizeType = TargetInfo::UnsignedInt;
901 this->PtrDiffType = TargetInfo::SignedInt;
902 this->IntPtrType = TargetInfo::SignedInt;
903 // RegParmMax is inherited from the underlying architecture.
904 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
905 if (Triple.getArch() == llvm::Triple::arm) {
906 // Handled in ARM's setABI().
907 } else if (Triple.getArch() == llvm::Triple::x86) {
908 this->resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-"
909 "i64:64-i128:128-n8:16:32-S128");
910 } else if (Triple.getArch() == llvm::Triple::x86_64) {
911 this->resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-"
912 "i64:64-i128:128-n8:16:32:64-S128");
913 } else if (Triple.getArch() == llvm::Triple::mipsel) {
914 // Handled on mips' setDataLayout.
915 }
916 }
917};
918
919// Fuchsia Target
920template <typename Target>
921class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> {
922protected:
923 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
924 MacroBuilder &Builder) const override {
925 Builder.defineMacro(Name: "__Fuchsia__");
926 if (Opts.POSIXThreads)
927 Builder.defineMacro(Name: "_REENTRANT");
928 // Required by the libc++ locale support.
929 if (Opts.CPlusPlus)
930 Builder.defineMacro(Name: "_GNU_SOURCE");
931 Builder.defineMacro(Name: "__Fuchsia_API_level__", Value: Twine(Opts.FuchsiaAPILevel));
932 this->PlatformName = "fuchsia";
933 this->PlatformMinVersion = VersionTuple(Opts.FuchsiaAPILevel);
934 }
935
936public:
937 FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
938 : OSTargetInfo<Target>(Triple, Opts) {
939 this->WIntType = TargetInfo::UnsignedInt;
940 this->MCountName = "__mcount";
941 this->TheCXXABI.set(TargetCXXABI::Fuchsia);
942 }
943};
944
945// WebAssembly target
946template <typename Target>
947class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo
948 : public OSTargetInfo<Target> {
949protected:
950 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
951 MacroBuilder &Builder) const override {
952 // A common platform macro.
953 if (Opts.POSIXThreads)
954 Builder.defineMacro(Name: "_REENTRANT");
955 // Follow g++ convention and predefine _GNU_SOURCE for C++.
956 if (Opts.CPlusPlus)
957 Builder.defineMacro(Name: "_GNU_SOURCE");
958 // Indicate that we have __float128.
959 Builder.defineMacro(Name: "__FLOAT128__");
960 }
961
962public:
963 explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple,
964 const TargetOptions &Opts)
965 : OSTargetInfo<Target>(Triple, Opts) {
966 this->MCountName = "__mcount";
967 this->TheCXXABI.set(TargetCXXABI::WebAssembly);
968 this->HasFloat128 = true;
969 }
970};
971
972// WASI target
973template <typename Target>
974class LLVM_LIBRARY_VISIBILITY WASITargetInfo
975 : public WebAssemblyOSTargetInfo<Target> {
976 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
977 MacroBuilder &Builder) const final {
978 WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);
979 Builder.defineMacro(Name: "__wasi__");
980 }
981
982public:
983 using WebAssemblyOSTargetInfo<Target>::WebAssemblyOSTargetInfo;
984};
985
986// Emscripten target
987template <typename Target>
988class LLVM_LIBRARY_VISIBILITY EmscriptenTargetInfo
989 : public WebAssemblyOSTargetInfo<Target> {
990 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
991 MacroBuilder &Builder) const final {
992 WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);
993 DefineStd(Builder, MacroName: "unix", Opts);
994 Builder.defineMacro(Name: "__EMSCRIPTEN__");
995 if (Opts.POSIXThreads)
996 Builder.defineMacro(Name: "__EMSCRIPTEN_PTHREADS__");
997 }
998
999public:
1000 explicit EmscriptenTargetInfo(const llvm::Triple &Triple,
1001 const TargetOptions &Opts)
1002 : WebAssemblyOSTargetInfo<Target>(Triple, Opts) {
1003 // Keeping the alignment of long double to 8 bytes even though its size is
1004 // 16 bytes allows emscripten to have an 8-byte-aligned max_align_t which
1005 // in turn gives is a 8-byte aligned malloc.
1006 // Emscripten's ABI is unstable and we may change this back to 128 to match
1007 // the WebAssembly default in the future.
1008 this->LongDoubleAlign = 64;
1009 this->Float128Align = 64;
1010 }
1011};
1012
1013// OHOS target
1014template <typename Target>
1015class LLVM_LIBRARY_VISIBILITY OHOSTargetInfo : public OSTargetInfo<Target> {
1016protected:
1017 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
1018 MacroBuilder &Builder) const override {
1019 // Linux defines; list based off of gcc output
1020 DefineStd(Builder, MacroName: "unix", Opts);
1021
1022 // Generic OHOS target defines
1023 if (Triple.isOHOSFamily()) {
1024 Builder.defineMacro(Name: "__OHOS_FAMILY__", Value: "1");
1025
1026 auto Version = Triple.getEnvironmentVersion();
1027 this->PlatformName = "ohos";
1028 this->PlatformMinVersion = Version;
1029 Builder.defineMacro(Name: "__OHOS_Major__", Value: Twine(Version.getMajor()));
1030 if (auto Minor = Version.getMinor())
1031 Builder.defineMacro(Name: "__OHOS_Minor__", Value: Twine(*Minor));
1032 if (auto Subminor = Version.getSubminor())
1033 Builder.defineMacro(Name: "__OHOS_Micro__", Value: Twine(*Subminor));
1034 }
1035
1036 if (Triple.isOpenHOS())
1037 Builder.defineMacro(Name: "__OHOS__");
1038
1039 if (Triple.isOSLinux()) {
1040 DefineStd(Builder, MacroName: "linux", Opts);
1041 } else if (Triple.isOSLiteOS()) {
1042 Builder.defineMacro(Name: "__LITEOS__");
1043 }
1044
1045 if (Opts.POSIXThreads)
1046 Builder.defineMacro(Name: "_REENTRANT");
1047 if (Opts.CPlusPlus)
1048 Builder.defineMacro(Name: "_GNU_SOURCE");
1049 if (this->HasFloat128)
1050 Builder.defineMacro(Name: "__FLOAT128__");
1051 }
1052
1053public:
1054 OHOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1055 : OSTargetInfo<Target>(Triple, Opts) {
1056 this->WIntType = TargetInfo::UnsignedInt;
1057
1058 switch (Triple.getArch()) {
1059 default:
1060 break;
1061 case llvm::Triple::x86:
1062 case llvm::Triple::x86_64:
1063 this->HasFloat128 = true;
1064 break;
1065 }
1066 }
1067
1068 const char *getStaticInitSectionSpecifier() const override {
1069 return ".text.startup";
1070 }
1071};
1072
1073} // namespace targets
1074} // namespace clang
1075#endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
1076

source code of clang/lib/Basic/Targets/OSTargets.h