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