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 from 9 onwards.
99 if (Triple.getArch() == llvm::Triple::x86_64 ||
100 Triple.getArch() == llvm::Triple::aarch64)
101 this->TLSSupported = !Triple.isOSVersionLT(8);
102 else if (Triple.getArch() == llvm::Triple::x86 ||
103 Triple.getArch() == llvm::Triple::arm ||
104 Triple.getArch() == llvm::Triple::thumb)
105 this->TLSSupported = !Triple.isOSVersionLT(9);
106 } else if (Triple.isWatchOS())
107 this->TLSSupported = !Triple.isOSVersionLT(2);
109 this->MCountName = "\01mcount";
112 std::string isValidSectionSpecifier(StringRef SR) const override {
113 // Let MCSectionMachO validate this.
114 StringRef Segment, Section;
115 unsigned TAA, StubSize;
117 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
118 TAA, HasTAA, StubSize);
121 const char *getStaticInitSectionSpecifier() const override {
122 // FIXME: We should return 0 when building kexts.
123 return "__TEXT,__StaticInit,regular,pure_instructions";
126 /// Darwin does not support protected visibility. Darwin's "default"
127 /// is very similar to ELF's "protected"; Darwin requires a "weak"
128 /// attribute on declarations that can be dynamically replaced.
129 bool hasProtectedVisibility() const override { return false; }
132 // DragonFlyBSD Target
133 template <typename Target>
134 class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo
135 : public OSTargetInfo<Target> {
137 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
138 MacroBuilder &Builder) const override {
139 // DragonFly defines; list based off of gcc output
140 Builder.defineMacro("__DragonFly__");
141 Builder.defineMacro("__DragonFly_cc_version", "100001");
142 Builder.defineMacro("__ELF__");
143 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
144 Builder.defineMacro("__tune_i386__");
145 DefineStd(Builder, "unix", Opts);
149 DragonFlyBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
150 : OSTargetInfo<Target>(Triple, Opts) {
151 switch (Triple.getArch()) {
153 case llvm::Triple::x86:
154 case llvm::Triple::x86_64:
155 this->MCountName = ".mcount";
161 #ifndef FREEBSD_CC_VERSION
162 #define FREEBSD_CC_VERSION 0U
166 template <typename Target>
167 class LLVM_LIBRARY_VISIBILITY FreeBSDTargetInfo : public OSTargetInfo<Target> {
169 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
170 MacroBuilder &Builder) const override {
171 // FreeBSD defines; list based off of gcc output
173 unsigned Release = Triple.getOSMajorVersion();
176 unsigned CCVersion = FREEBSD_CC_VERSION;
178 CCVersion = Release * 100000U + 1U;
180 Builder.defineMacro("__FreeBSD__", Twine(Release));
181 Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion));
182 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
183 DefineStd(Builder, "unix", Opts);
184 Builder.defineMacro("__ELF__");
186 // On FreeBSD, wchar_t contains the number of the code point as
187 // used by the character set of the locale. These character sets are
188 // not necessarily a superset of ASCII.
190 // FIXME: This is wrong; the macro refers to the numerical values
191 // of wchar_t *literals*, which are not locale-dependent. However,
192 // FreeBSD systems apparently depend on us getting this wrong, and
193 // setting this to 1 is conforming even if all the basic source
194 // character literals have the same encoding as char and wchar_t.
195 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
199 FreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
200 : OSTargetInfo<Target>(Triple, Opts) {
201 switch (Triple.getArch()) {
203 case llvm::Triple::x86:
204 case llvm::Triple::x86_64:
205 this->MCountName = ".mcount";
207 case llvm::Triple::mips:
208 case llvm::Triple::mipsel:
209 case llvm::Triple::ppc:
210 case llvm::Triple::ppc64:
211 case llvm::Triple::ppc64le:
212 this->MCountName = "_mcount";
214 case llvm::Triple::arm:
215 this->MCountName = "__mcount";
221 // GNU/kFreeBSD Target
222 template <typename Target>
223 class LLVM_LIBRARY_VISIBILITY KFreeBSDTargetInfo : public OSTargetInfo<Target> {
225 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
226 MacroBuilder &Builder) const override {
227 // GNU/kFreeBSD defines; list based off of gcc output
229 DefineStd(Builder, "unix", Opts);
230 Builder.defineMacro("__FreeBSD_kernel__");
231 Builder.defineMacro("__GLIBC__");
232 Builder.defineMacro("__ELF__");
233 if (Opts.POSIXThreads)
234 Builder.defineMacro("_REENTRANT");
236 Builder.defineMacro("_GNU_SOURCE");
240 KFreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
241 : OSTargetInfo<Target>(Triple, Opts) {}
245 template <typename Target>
246 class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> {
248 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
249 MacroBuilder &Builder) const override {
250 // Haiku defines; list based off of gcc output
251 Builder.defineMacro("__HAIKU__");
252 Builder.defineMacro("__ELF__");
253 DefineStd(Builder, "unix", Opts);
257 HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
258 : OSTargetInfo<Target>(Triple, Opts) {
259 this->SizeType = TargetInfo::UnsignedLong;
260 this->IntPtrType = TargetInfo::SignedLong;
261 this->PtrDiffType = TargetInfo::SignedLong;
262 this->ProcessIDType = TargetInfo::SignedLong;
263 this->TLSSupported = false;
268 template <typename Target>
269 class LLVM_LIBRARY_VISIBILITY MinixTargetInfo : public OSTargetInfo<Target> {
271 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
272 MacroBuilder &Builder) const override {
275 Builder.defineMacro("__minix", "3");
276 Builder.defineMacro("_EM_WSIZE", "4");
277 Builder.defineMacro("_EM_PSIZE", "4");
278 Builder.defineMacro("_EM_SSIZE", "2");
279 Builder.defineMacro("_EM_LSIZE", "4");
280 Builder.defineMacro("_EM_FSIZE", "4");
281 Builder.defineMacro("_EM_DSIZE", "8");
282 Builder.defineMacro("__ELF__");
283 DefineStd(Builder, "unix", Opts);
287 MinixTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
288 : OSTargetInfo<Target>(Triple, Opts) {}
292 template <typename Target>
293 class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {
295 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
296 MacroBuilder &Builder) const override {
297 // Linux defines; list based off of gcc output
298 DefineStd(Builder, "unix", Opts);
299 DefineStd(Builder, "linux", Opts);
300 Builder.defineMacro("__gnu_linux__");
301 Builder.defineMacro("__ELF__");
302 if (Triple.isAndroid()) {
303 Builder.defineMacro("__ANDROID__", "1");
304 unsigned Maj, Min, Rev;
305 Triple.getEnvironmentVersion(Maj, Min, Rev);
306 this->PlatformName = "android";
307 this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
309 Builder.defineMacro("__ANDROID_API__", Twine(Maj));
311 if (Opts.POSIXThreads)
312 Builder.defineMacro("_REENTRANT");
314 Builder.defineMacro("_GNU_SOURCE");
315 if (this->HasFloat128)
316 Builder.defineMacro("__FLOAT128__");
320 LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
321 : OSTargetInfo<Target>(Triple, Opts) {
322 this->WIntType = TargetInfo::UnsignedInt;
324 switch (Triple.getArch()) {
327 case llvm::Triple::mips:
328 case llvm::Triple::mipsel:
329 case llvm::Triple::mips64:
330 case llvm::Triple::mips64el:
331 case llvm::Triple::ppc:
332 case llvm::Triple::ppc64:
333 case llvm::Triple::ppc64le:
334 this->MCountName = "_mcount";
336 case llvm::Triple::x86:
337 case llvm::Triple::x86_64:
338 case llvm::Triple::systemz:
339 this->HasFloat128 = true;
344 const char *getStaticInitSectionSpecifier() const override {
345 return ".text.startup";
350 template <typename Target>
351 class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> {
353 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
354 MacroBuilder &Builder) const override {
355 // NetBSD defines; list based off of gcc output
356 Builder.defineMacro("__NetBSD__");
357 Builder.defineMacro("__unix__");
358 Builder.defineMacro("__ELF__");
359 if (Opts.POSIXThreads)
360 Builder.defineMacro("_REENTRANT");
364 NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
365 : OSTargetInfo<Target>(Triple, Opts) {
366 this->MCountName = "_mcount";
371 template <typename Target>
372 class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> {
374 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
375 MacroBuilder &Builder) const override {
376 // OpenBSD defines; list based off of gcc output
378 Builder.defineMacro("__OpenBSD__");
379 DefineStd(Builder, "unix", Opts);
380 Builder.defineMacro("__ELF__");
381 if (Opts.POSIXThreads)
382 Builder.defineMacro("_REENTRANT");
383 if (this->HasFloat128)
384 Builder.defineMacro("__FLOAT128__");
388 OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
389 : OSTargetInfo<Target>(Triple, Opts) {
390 switch (Triple.getArch()) {
391 case llvm::Triple::x86:
392 case llvm::Triple::x86_64:
393 this->HasFloat128 = true;
396 this->MCountName = "__mcount";
398 case llvm::Triple::mips64:
399 case llvm::Triple::mips64el:
400 case llvm::Triple::ppc:
401 case llvm::Triple::sparcv9:
402 this->MCountName = "_mcount";
409 template <typename Target>
410 class LLVM_LIBRARY_VISIBILITY PSPTargetInfo : public OSTargetInfo<Target> {
412 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
413 MacroBuilder &Builder) const override {
414 // PSP defines; list based on the output of the pspdev gcc toolchain.
415 Builder.defineMacro("PSP");
416 Builder.defineMacro("_PSP");
417 Builder.defineMacro("__psp__");
418 Builder.defineMacro("__ELF__");
422 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {}
426 template <typename Target>
427 class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> {
429 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
430 MacroBuilder &Builder) const override {
432 Builder.defineMacro("__PPC__");
433 Builder.defineMacro("__PPU__");
434 Builder.defineMacro("__CELLOS_LV2__");
435 Builder.defineMacro("__ELF__");
436 Builder.defineMacro("__LP32__");
437 Builder.defineMacro("_ARCH_PPC64");
438 Builder.defineMacro("__powerpc64__");
442 PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
443 : OSTargetInfo<Target>(Triple, Opts) {
444 this->LongWidth = this->LongAlign = 32;
445 this->PointerWidth = this->PointerAlign = 32;
446 this->IntMaxType = TargetInfo::SignedLongLong;
447 this->Int64Type = TargetInfo::SignedLongLong;
448 this->SizeType = TargetInfo::UnsignedInt;
449 this->resetDataLayout("E-m:e-p:32:32-i64:64-n32:64");
453 template <typename Target>
454 class LLVM_LIBRARY_VISIBILITY PS4OSTargetInfo : public OSTargetInfo<Target> {
456 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
457 MacroBuilder &Builder) const override {
458 Builder.defineMacro("__FreeBSD__", "9");
459 Builder.defineMacro("__FreeBSD_cc_version", "900001");
460 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
461 DefineStd(Builder, "unix", Opts);
462 Builder.defineMacro("__ELF__");
463 Builder.defineMacro("__ORBIS__");
467 PS4OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
468 : OSTargetInfo<Target>(Triple, Opts) {
469 this->WCharType = TargetInfo::UnsignedShort;
471 // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
472 this->MaxTLSAlign = 256;
474 // On PS4, do not honor explicit bit field alignment,
475 // as in "__attribute__((aligned(2))) int b : 1;".
476 this->UseExplicitBitFieldAlignment = false;
478 switch (Triple.getArch()) {
480 case llvm::Triple::x86_64:
481 this->MCountName = ".mcount";
488 template <typename Target>
489 class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> {
491 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
492 MacroBuilder &Builder) const override {
493 // RTEMS defines; list based off of gcc output
495 Builder.defineMacro("__rtems__");
496 Builder.defineMacro("__ELF__");
498 Builder.defineMacro("_GNU_SOURCE");
502 RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
503 : OSTargetInfo<Target>(Triple, Opts) {
504 switch (Triple.getArch()) {
506 case llvm::Triple::x86:
507 // this->MCountName = ".mcount";
509 case llvm::Triple::mips:
510 case llvm::Triple::mipsel:
511 case llvm::Triple::ppc:
512 case llvm::Triple::ppc64:
513 case llvm::Triple::ppc64le:
514 // this->MCountName = "_mcount";
516 case llvm::Triple::arm:
517 // this->MCountName = "__mcount";
524 template <typename Target>
525 class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> {
527 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
528 MacroBuilder &Builder) const override {
529 DefineStd(Builder, "sun", Opts);
530 DefineStd(Builder, "unix", Opts);
531 Builder.defineMacro("__ELF__");
532 Builder.defineMacro("__svr4__");
533 Builder.defineMacro("__SVR4");
534 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
535 // newer, but to 500 for everything else. feature_test.h has a check to
536 // ensure that you are not using C99 with an old version of X/Open or C89
537 // with a new version.
539 Builder.defineMacro("_XOPEN_SOURCE", "600");
541 Builder.defineMacro("_XOPEN_SOURCE", "500");
543 Builder.defineMacro("__C99FEATURES__");
544 Builder.defineMacro("_LARGEFILE_SOURCE");
545 Builder.defineMacro("_LARGEFILE64_SOURCE");
546 Builder.defineMacro("__EXTENSIONS__");
547 Builder.defineMacro("_REENTRANT");
551 SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
552 : OSTargetInfo<Target>(Triple, Opts) {
553 // FIXME: WIntType should be SignedLong
558 template <typename Target>
559 class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> {
561 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
562 MacroBuilder &Builder) const override {
563 Builder.defineMacro("_WIN32");
564 if (Triple.isArch64Bit())
565 Builder.defineMacro("_WIN64");
566 if (Triple.isWindowsGNUEnvironment())
567 addMinGWDefines(Triple, Opts, Builder);
570 void getVisualStudioDefines(const LangOptions &Opts,
571 MacroBuilder &Builder) const {
572 if (Opts.CPlusPlus) {
574 Builder.defineMacro("_CPPRTTI");
576 if (Opts.CXXExceptions)
577 Builder.defineMacro("_CPPUNWIND");
581 Builder.defineMacro("__BOOL_DEFINED");
583 if (!Opts.CharIsSigned)
584 Builder.defineMacro("_CHAR_UNSIGNED");
586 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
587 // but it works for now.
588 if (Opts.POSIXThreads)
589 Builder.defineMacro("_MT");
591 if (Opts.MSCompatibilityVersion) {
592 Builder.defineMacro("_MSC_VER",
593 Twine(Opts.MSCompatibilityVersion / 100000));
594 Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
595 // FIXME We cannot encode the revision information into 32-bits
596 Builder.defineMacro("_MSC_BUILD", Twine(1));
598 if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
599 Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
601 if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) {
602 if (Opts.CPlusPlus17)
603 Builder.defineMacro("_MSVC_LANG", "201403L");
604 else if (Opts.CPlusPlus14)
605 Builder.defineMacro("_MSVC_LANG", "201402L");
609 if (Opts.MicrosoftExt) {
610 Builder.defineMacro("_MSC_EXTENSIONS");
612 if (Opts.CPlusPlus11) {
613 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
614 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
615 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
619 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
623 WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
624 : OSTargetInfo<Target>(Triple, Opts) {
625 this->WCharType = TargetInfo::UnsignedShort;
629 template <typename Target>
630 class LLVM_LIBRARY_VISIBILITY NaClTargetInfo : public OSTargetInfo<Target> {
632 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
633 MacroBuilder &Builder) const override {
634 if (Opts.POSIXThreads)
635 Builder.defineMacro("_REENTRANT");
637 Builder.defineMacro("_GNU_SOURCE");
639 DefineStd(Builder, "unix", Opts);
640 Builder.defineMacro("__ELF__");
641 Builder.defineMacro("__native_client__");
645 NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
646 : OSTargetInfo<Target>(Triple, Opts) {
647 this->LongAlign = 32;
648 this->LongWidth = 32;
649 this->PointerAlign = 32;
650 this->PointerWidth = 32;
651 this->IntMaxType = TargetInfo::SignedLongLong;
652 this->Int64Type = TargetInfo::SignedLongLong;
653 this->DoubleAlign = 64;
654 this->LongDoubleWidth = 64;
655 this->LongDoubleAlign = 64;
656 this->LongLongWidth = 64;
657 this->LongLongAlign = 64;
658 this->SizeType = TargetInfo::UnsignedInt;
659 this->PtrDiffType = TargetInfo::SignedInt;
660 this->IntPtrType = TargetInfo::SignedInt;
661 // RegParmMax is inherited from the underlying architecture.
662 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
663 if (Triple.getArch() == llvm::Triple::arm) {
664 // Handled in ARM's setABI().
665 } else if (Triple.getArch() == llvm::Triple::x86) {
666 this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32-S128");
667 } else if (Triple.getArch() == llvm::Triple::x86_64) {
668 this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32:64-S128");
669 } else if (Triple.getArch() == llvm::Triple::mipsel) {
670 // Handled on mips' setDataLayout.
672 assert(Triple.getArch() == llvm::Triple::le32);
673 this->resetDataLayout("e-p:32:32-i64:64");
679 template <typename Target>
680 class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> {
682 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
683 MacroBuilder &Builder) const override {
684 Builder.defineMacro("__Fuchsia__");
685 Builder.defineMacro("__ELF__");
686 if (Opts.POSIXThreads)
687 Builder.defineMacro("_REENTRANT");
688 // Required by the libc++ locale support.
690 Builder.defineMacro("_GNU_SOURCE");
694 FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
695 : OSTargetInfo<Target>(Triple, Opts) {
696 this->MCountName = "__mcount";
700 // WebAssembly target
701 template <typename Target>
702 class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo
703 : public OSTargetInfo<Target> {
704 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
705 MacroBuilder &Builder) const final {
706 // A common platform macro.
707 if (Opts.POSIXThreads)
708 Builder.defineMacro("_REENTRANT");
709 // Follow g++ convention and predefine _GNU_SOURCE for C++.
711 Builder.defineMacro("_GNU_SOURCE");
715 explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple,
716 const TargetOptions &Opts)
717 : OSTargetInfo<Target>(Triple, Opts) {
718 this->MCountName = "__mcount";
719 this->TheCXXABI.set(TargetCXXABI::WebAssembly);
723 } // namespace targets
725 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H