1 //===--- OSTargets.h - Declare OS target feature support --------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file declares OS specific TargetInfo types.
11 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
14 #define LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
17 #include "llvm/MC/MCSectionMachO.h"
22 template <typename TgtInfo>
23 class LLVM_LIBRARY_VISIBILITY OSTargetInfo : public TgtInfo {
25 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
26 MacroBuilder &Builder) const = 0;
29 OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
30 : TgtInfo(Triple, Opts) {}
32 void getTargetDefines(const LangOptions &Opts,
33 MacroBuilder &Builder) const override {
34 TgtInfo::getTargetDefines(Opts, Builder);
35 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
40 template <typename Target>
41 class LLVM_LIBRARY_VISIBILITY CloudABITargetInfo : public OSTargetInfo<Target> {
43 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
44 MacroBuilder &Builder) const override {
45 Builder.defineMacro("__CloudABI__");
46 Builder.defineMacro("__ELF__");
48 // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
49 Builder.defineMacro("__STDC_ISO_10646__", "201206L");
50 Builder.defineMacro("__STDC_UTF_16__");
51 Builder.defineMacro("__STDC_UTF_32__");
55 CloudABITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
56 : OSTargetInfo<Target>(Triple, Opts) {}
60 template <typename Target>
61 class LLVM_LIBRARY_VISIBILITY AnanasTargetInfo : public OSTargetInfo<Target> {
63 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
64 MacroBuilder &Builder) const override {
66 Builder.defineMacro("__Ananas__");
67 Builder.defineMacro("__ELF__");
71 AnanasTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
72 : OSTargetInfo<Target>(Triple, Opts) {}
75 void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
76 const llvm::Triple &Triple, StringRef &PlatformName,
77 VersionTuple &PlatformMinVersion);
79 template <typename Target>
80 class LLVM_LIBRARY_VISIBILITY DarwinTargetInfo : public OSTargetInfo<Target> {
82 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
83 MacroBuilder &Builder) const override {
84 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
85 this->PlatformMinVersion);
89 DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
90 : OSTargetInfo<Target>(Triple, Opts) {
91 // By default, no TLS, and we whitelist permitted architecture/OS
93 this->TLSSupported = false;
95 if (Triple.isMacOSX())
96 this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7);
97 else if (Triple.isiOS()) {
98 // 64-bit iOS supported it from 8 onwards, 32-bit device from 9 onwards,
99 // 32-bit simulator from 10 onwards.
100 if (Triple.isArch64Bit())
101 this->TLSSupported = !Triple.isOSVersionLT(8);
102 else if (Triple.isArch32Bit()) {
103 if (!Triple.isSimulatorEnvironment())
104 this->TLSSupported = !Triple.isOSVersionLT(9);
106 this->TLSSupported = !Triple.isOSVersionLT(10);
108 } else if (Triple.isWatchOS()) {
109 if (!Triple.isSimulatorEnvironment())
110 this->TLSSupported = !Triple.isOSVersionLT(2);
112 this->TLSSupported = !Triple.isOSVersionLT(3);
115 this->MCountName = "\01mcount";
118 std::string isValidSectionSpecifier(StringRef SR) const override {
119 // Let MCSectionMachO validate this.
120 StringRef Segment, Section;
121 unsigned TAA, StubSize;
123 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
124 TAA, HasTAA, StubSize);
127 const char *getStaticInitSectionSpecifier() const override {
128 // FIXME: We should return 0 when building kexts.
129 return "__TEXT,__StaticInit,regular,pure_instructions";
132 /// Darwin does not support protected visibility. Darwin's "default"
133 /// is very similar to ELF's "protected"; Darwin requires a "weak"
134 /// attribute on declarations that can be dynamically replaced.
135 bool hasProtectedVisibility() const override { return false; }
138 // DragonFlyBSD Target
139 template <typename Target>
140 class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo
141 : public OSTargetInfo<Target> {
143 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
144 MacroBuilder &Builder) const override {
145 // DragonFly defines; list based off of gcc output
146 Builder.defineMacro("__DragonFly__");
147 Builder.defineMacro("__DragonFly_cc_version", "100001");
148 Builder.defineMacro("__ELF__");
149 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
150 Builder.defineMacro("__tune_i386__");
151 DefineStd(Builder, "unix", Opts);
155 DragonFlyBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
156 : OSTargetInfo<Target>(Triple, Opts) {
157 switch (Triple.getArch()) {
159 case llvm::Triple::x86:
160 case llvm::Triple::x86_64:
161 this->MCountName = ".mcount";
167 #ifndef FREEBSD_CC_VERSION
168 #define FREEBSD_CC_VERSION 0U
172 template <typename Target>
173 class LLVM_LIBRARY_VISIBILITY FreeBSDTargetInfo : public OSTargetInfo<Target> {
175 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
176 MacroBuilder &Builder) const override {
177 // FreeBSD defines; list based off of gcc output
179 unsigned Release = Triple.getOSMajorVersion();
182 unsigned CCVersion = FREEBSD_CC_VERSION;
184 CCVersion = Release * 100000U + 1U;
186 Builder.defineMacro("__FreeBSD__", Twine(Release));
187 Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion));
188 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
189 DefineStd(Builder, "unix", Opts);
190 Builder.defineMacro("__ELF__");
192 // On FreeBSD, wchar_t contains the number of the code point as
193 // used by the character set of the locale. These character sets are
194 // not necessarily a superset of ASCII.
196 // FIXME: This is wrong; the macro refers to the numerical values
197 // of wchar_t *literals*, which are not locale-dependent. However,
198 // FreeBSD systems apparently depend on us getting this wrong, and
199 // setting this to 1 is conforming even if all the basic source
200 // character literals have the same encoding as char and wchar_t.
201 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
205 FreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
206 : OSTargetInfo<Target>(Triple, Opts) {
207 switch (Triple.getArch()) {
209 case llvm::Triple::x86:
210 case llvm::Triple::x86_64:
211 this->MCountName = ".mcount";
213 case llvm::Triple::mips:
214 case llvm::Triple::mipsel:
215 case llvm::Triple::ppc:
216 case llvm::Triple::ppc64:
217 case llvm::Triple::ppc64le:
218 this->MCountName = "_mcount";
220 case llvm::Triple::arm:
221 this->MCountName = "__mcount";
227 // GNU/kFreeBSD Target
228 template <typename Target>
229 class LLVM_LIBRARY_VISIBILITY KFreeBSDTargetInfo : public OSTargetInfo<Target> {
231 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
232 MacroBuilder &Builder) const override {
233 // GNU/kFreeBSD defines; list based off of gcc output
235 DefineStd(Builder, "unix", Opts);
236 Builder.defineMacro("__FreeBSD_kernel__");
237 Builder.defineMacro("__GLIBC__");
238 Builder.defineMacro("__ELF__");
239 if (Opts.POSIXThreads)
240 Builder.defineMacro("_REENTRANT");
242 Builder.defineMacro("_GNU_SOURCE");
246 KFreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
247 : OSTargetInfo<Target>(Triple, Opts) {}
251 template <typename Target>
252 class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> {
254 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
255 MacroBuilder &Builder) const override {
256 // Haiku defines; list based off of gcc output
257 Builder.defineMacro("__HAIKU__");
258 Builder.defineMacro("__ELF__");
259 DefineStd(Builder, "unix", Opts);
263 HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
264 : OSTargetInfo<Target>(Triple, Opts) {
265 this->SizeType = TargetInfo::UnsignedLong;
266 this->IntPtrType = TargetInfo::SignedLong;
267 this->PtrDiffType = TargetInfo::SignedLong;
268 this->ProcessIDType = TargetInfo::SignedLong;
269 this->TLSSupported = false;
274 template <typename Target>
275 class LLVM_LIBRARY_VISIBILITY MinixTargetInfo : public OSTargetInfo<Target> {
277 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
278 MacroBuilder &Builder) const override {
281 Builder.defineMacro("__minix", "3");
282 Builder.defineMacro("_EM_WSIZE", "4");
283 Builder.defineMacro("_EM_PSIZE", "4");
284 Builder.defineMacro("_EM_SSIZE", "2");
285 Builder.defineMacro("_EM_LSIZE", "4");
286 Builder.defineMacro("_EM_FSIZE", "4");
287 Builder.defineMacro("_EM_DSIZE", "8");
288 Builder.defineMacro("__ELF__");
289 DefineStd(Builder, "unix", Opts);
293 MinixTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
294 : OSTargetInfo<Target>(Triple, Opts) {}
298 template <typename Target>
299 class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {
301 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
302 MacroBuilder &Builder) const override {
303 // Linux defines; list based off of gcc output
304 DefineStd(Builder, "unix", Opts);
305 DefineStd(Builder, "linux", Opts);
306 Builder.defineMacro("__gnu_linux__");
307 Builder.defineMacro("__ELF__");
308 if (Triple.isAndroid()) {
309 Builder.defineMacro("__ANDROID__", "1");
310 unsigned Maj, Min, Rev;
311 Triple.getEnvironmentVersion(Maj, Min, Rev);
312 this->PlatformName = "android";
313 this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
315 Builder.defineMacro("__ANDROID_API__", Twine(Maj));
317 if (Opts.POSIXThreads)
318 Builder.defineMacro("_REENTRANT");
320 Builder.defineMacro("_GNU_SOURCE");
321 if (this->HasFloat128)
322 Builder.defineMacro("__FLOAT128__");
326 LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
327 : OSTargetInfo<Target>(Triple, Opts) {
328 this->WIntType = TargetInfo::UnsignedInt;
330 switch (Triple.getArch()) {
333 case llvm::Triple::mips:
334 case llvm::Triple::mipsel:
335 case llvm::Triple::mips64:
336 case llvm::Triple::mips64el:
337 case llvm::Triple::ppc:
338 case llvm::Triple::ppc64:
339 case llvm::Triple::ppc64le:
340 this->MCountName = "_mcount";
342 case llvm::Triple::x86:
343 case llvm::Triple::x86_64:
344 case llvm::Triple::systemz:
345 this->HasFloat128 = true;
350 const char *getStaticInitSectionSpecifier() const override {
351 return ".text.startup";
356 template <typename Target>
357 class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> {
359 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
360 MacroBuilder &Builder) const override {
361 // NetBSD defines; list based off of gcc output
362 Builder.defineMacro("__NetBSD__");
363 Builder.defineMacro("__unix__");
364 Builder.defineMacro("__ELF__");
365 if (Opts.POSIXThreads)
366 Builder.defineMacro("_REENTRANT");
370 NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
371 : OSTargetInfo<Target>(Triple, Opts) {
372 this->MCountName = "__mcount";
377 template <typename Target>
378 class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> {
380 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
381 MacroBuilder &Builder) const override {
382 // OpenBSD defines; list based off of gcc output
384 Builder.defineMacro("__OpenBSD__");
385 DefineStd(Builder, "unix", Opts);
386 Builder.defineMacro("__ELF__");
387 if (Opts.POSIXThreads)
388 Builder.defineMacro("_REENTRANT");
389 if (this->HasFloat128)
390 Builder.defineMacro("__FLOAT128__");
394 OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
395 : OSTargetInfo<Target>(Triple, Opts) {
396 switch (Triple.getArch()) {
397 case llvm::Triple::x86:
398 case llvm::Triple::x86_64:
399 this->HasFloat128 = true;
402 this->MCountName = "__mcount";
404 case llvm::Triple::mips64:
405 case llvm::Triple::mips64el:
406 case llvm::Triple::ppc:
407 case llvm::Triple::sparcv9:
408 this->MCountName = "_mcount";
415 template <typename Target>
416 class LLVM_LIBRARY_VISIBILITY PSPTargetInfo : public OSTargetInfo<Target> {
418 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
419 MacroBuilder &Builder) const override {
420 // PSP defines; list based on the output of the pspdev gcc toolchain.
421 Builder.defineMacro("PSP");
422 Builder.defineMacro("_PSP");
423 Builder.defineMacro("__psp__");
424 Builder.defineMacro("__ELF__");
428 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {}
432 template <typename Target>
433 class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> {
435 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
436 MacroBuilder &Builder) const override {
438 Builder.defineMacro("__PPC__");
439 Builder.defineMacro("__PPU__");
440 Builder.defineMacro("__CELLOS_LV2__");
441 Builder.defineMacro("__ELF__");
442 Builder.defineMacro("__LP32__");
443 Builder.defineMacro("_ARCH_PPC64");
444 Builder.defineMacro("__powerpc64__");
448 PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
449 : OSTargetInfo<Target>(Triple, Opts) {
450 this->LongWidth = this->LongAlign = 32;
451 this->PointerWidth = this->PointerAlign = 32;
452 this->IntMaxType = TargetInfo::SignedLongLong;
453 this->Int64Type = TargetInfo::SignedLongLong;
454 this->SizeType = TargetInfo::UnsignedInt;
455 this->resetDataLayout("E-m:e-p:32:32-i64:64-n32:64");
459 template <typename Target>
460 class LLVM_LIBRARY_VISIBILITY PS4OSTargetInfo : public OSTargetInfo<Target> {
462 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
463 MacroBuilder &Builder) const override {
464 Builder.defineMacro("__FreeBSD__", "9");
465 Builder.defineMacro("__FreeBSD_cc_version", "900001");
466 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
467 DefineStd(Builder, "unix", Opts);
468 Builder.defineMacro("__ELF__");
469 Builder.defineMacro("__ORBIS__");
473 PS4OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
474 : OSTargetInfo<Target>(Triple, Opts) {
475 this->WCharType = TargetInfo::UnsignedShort;
477 // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
478 this->MaxTLSAlign = 256;
480 // On PS4, do not honor explicit bit field alignment,
481 // as in "__attribute__((aligned(2))) int b : 1;".
482 this->UseExplicitBitFieldAlignment = false;
484 switch (Triple.getArch()) {
486 case llvm::Triple::x86_64:
487 this->MCountName = ".mcount";
488 this->NewAlign = 256;
495 template <typename Target>
496 class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> {
498 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
499 MacroBuilder &Builder) const override {
500 // RTEMS defines; list based off of gcc output
502 Builder.defineMacro("__rtems__");
503 Builder.defineMacro("__ELF__");
505 Builder.defineMacro("_GNU_SOURCE");
509 RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
510 : OSTargetInfo<Target>(Triple, Opts) {
511 switch (Triple.getArch()) {
513 case llvm::Triple::x86:
514 // this->MCountName = ".mcount";
516 case llvm::Triple::mips:
517 case llvm::Triple::mipsel:
518 case llvm::Triple::ppc:
519 case llvm::Triple::ppc64:
520 case llvm::Triple::ppc64le:
521 // this->MCountName = "_mcount";
523 case llvm::Triple::arm:
524 // this->MCountName = "__mcount";
531 template <typename Target>
532 class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> {
534 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
535 MacroBuilder &Builder) const override {
536 DefineStd(Builder, "sun", Opts);
537 DefineStd(Builder, "unix", Opts);
538 Builder.defineMacro("__ELF__");
539 Builder.defineMacro("__svr4__");
540 Builder.defineMacro("__SVR4");
541 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
542 // newer, but to 500 for everything else. feature_test.h has a check to
543 // ensure that you are not using C99 with an old version of X/Open or C89
544 // with a new version.
546 Builder.defineMacro("_XOPEN_SOURCE", "600");
548 Builder.defineMacro("_XOPEN_SOURCE", "500");
550 Builder.defineMacro("__C99FEATURES__");
551 Builder.defineMacro("_LARGEFILE_SOURCE");
552 Builder.defineMacro("_LARGEFILE64_SOURCE");
553 Builder.defineMacro("__EXTENSIONS__");
554 if (Opts.POSIXThreads)
555 Builder.defineMacro("_REENTRANT");
556 if (this->HasFloat128)
557 Builder.defineMacro("__FLOAT128__");
561 SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
562 : OSTargetInfo<Target>(Triple, Opts) {
563 // FIXME: WIntType should be SignedLong
564 switch (Triple.getArch()) {
567 case llvm::Triple::x86:
568 case llvm::Triple::x86_64:
569 this->HasFloat128 = true;
576 template <typename Target>
577 class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> {
579 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
580 MacroBuilder &Builder) const override {
581 Builder.defineMacro("_WIN32");
582 if (Triple.isArch64Bit())
583 Builder.defineMacro("_WIN64");
584 if (Triple.isWindowsGNUEnvironment())
585 addMinGWDefines(Triple, Opts, Builder);
588 void getVisualStudioDefines(const LangOptions &Opts,
589 MacroBuilder &Builder) const {
590 if (Opts.CPlusPlus) {
592 Builder.defineMacro("_CPPRTTI");
594 if (Opts.CXXExceptions)
595 Builder.defineMacro("_CPPUNWIND");
599 Builder.defineMacro("__BOOL_DEFINED");
601 if (!Opts.CharIsSigned)
602 Builder.defineMacro("_CHAR_UNSIGNED");
604 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
605 // but it works for now.
606 if (Opts.POSIXThreads)
607 Builder.defineMacro("_MT");
609 if (Opts.MSCompatibilityVersion) {
610 Builder.defineMacro("_MSC_VER",
611 Twine(Opts.MSCompatibilityVersion / 100000));
612 Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
613 // FIXME We cannot encode the revision information into 32-bits
614 Builder.defineMacro("_MSC_BUILD", Twine(1));
616 if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
617 Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
619 if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) {
620 if (Opts.CPlusPlus2a)
621 Builder.defineMacro("_MSVC_LANG", "201704L");
622 else if (Opts.CPlusPlus17)
623 Builder.defineMacro("_MSVC_LANG", "201703L");
624 else if (Opts.CPlusPlus14)
625 Builder.defineMacro("_MSVC_LANG", "201402L");
629 if (Opts.MicrosoftExt) {
630 Builder.defineMacro("_MSC_EXTENSIONS");
632 if (Opts.CPlusPlus11) {
633 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
634 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
635 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
639 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
643 WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
644 : OSTargetInfo<Target>(Triple, Opts) {
645 this->WCharType = TargetInfo::UnsignedShort;
649 template <typename Target>
650 class LLVM_LIBRARY_VISIBILITY NaClTargetInfo : public OSTargetInfo<Target> {
652 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
653 MacroBuilder &Builder) const override {
654 if (Opts.POSIXThreads)
655 Builder.defineMacro("_REENTRANT");
657 Builder.defineMacro("_GNU_SOURCE");
659 DefineStd(Builder, "unix", Opts);
660 Builder.defineMacro("__ELF__");
661 Builder.defineMacro("__native_client__");
665 NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
666 : OSTargetInfo<Target>(Triple, Opts) {
667 this->LongAlign = 32;
668 this->LongWidth = 32;
669 this->PointerAlign = 32;
670 this->PointerWidth = 32;
671 this->IntMaxType = TargetInfo::SignedLongLong;
672 this->Int64Type = TargetInfo::SignedLongLong;
673 this->DoubleAlign = 64;
674 this->LongDoubleWidth = 64;
675 this->LongDoubleAlign = 64;
676 this->LongLongWidth = 64;
677 this->LongLongAlign = 64;
678 this->SizeType = TargetInfo::UnsignedInt;
679 this->PtrDiffType = TargetInfo::SignedInt;
680 this->IntPtrType = TargetInfo::SignedInt;
681 // RegParmMax is inherited from the underlying architecture.
682 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
683 if (Triple.getArch() == llvm::Triple::arm) {
684 // Handled in ARM's setABI().
685 } else if (Triple.getArch() == llvm::Triple::x86) {
686 this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32-S128");
687 } else if (Triple.getArch() == llvm::Triple::x86_64) {
688 this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32:64-S128");
689 } else if (Triple.getArch() == llvm::Triple::mipsel) {
690 // Handled on mips' setDataLayout.
692 assert(Triple.getArch() == llvm::Triple::le32);
693 this->resetDataLayout("e-p:32:32-i64:64");
699 template <typename Target>
700 class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> {
702 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
703 MacroBuilder &Builder) const override {
704 Builder.defineMacro("__Fuchsia__");
705 Builder.defineMacro("__ELF__");
706 if (Opts.POSIXThreads)
707 Builder.defineMacro("_REENTRANT");
708 // Required by the libc++ locale support.
710 Builder.defineMacro("_GNU_SOURCE");
714 FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
715 : OSTargetInfo<Target>(Triple, Opts) {
716 this->MCountName = "__mcount";
720 // WebAssembly target
721 template <typename Target>
722 class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo
723 : public OSTargetInfo<Target> {
724 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
725 MacroBuilder &Builder) const final {
726 // A common platform macro.
727 if (Opts.POSIXThreads)
728 Builder.defineMacro("_REENTRANT");
729 // Follow g++ convention and predefine _GNU_SOURCE for C++.
731 Builder.defineMacro("_GNU_SOURCE");
735 explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple,
736 const TargetOptions &Opts)
737 : OSTargetInfo<Target>(Triple, Opts) {
738 this->MCountName = "__mcount";
739 this->TheCXXABI.set(TargetCXXABI::WebAssembly);
743 } // namespace targets
745 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H