1064 lines · c
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-exception6//7//===----------------------------------------------------------------------===//8//9// This file declares OS specific TargetInfo types.10//===----------------------------------------------------------------------===//11 12#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H13#define LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H14 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, 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 AppleMachOTargetInfo46 : 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 very62 /// similar to ELF's "protected"; Apple Mach-O requires a "weak" attribute on63 /// declarations that can be dynamically replaced.64 bool hasProtectedVisibility() const override { return false; }65};66 67template <typename Target>68class LLVM_LIBRARY_VISIBILITY DarwinTargetInfo69 : 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/OS81 // combinations.82 this->TLSSupported = false;83 84 if (Triple.isMacOSX())85 this->TLSSupported = !Triple.isMacOSXVersionLT(10, 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(8);91 else if (Triple.isArch32Bit()) {92 if (!Triple.isSimulatorEnvironment())93 this->TLSSupported = !Triple.isOSVersionLT(9);94 else95 this->TLSSupported = !Triple.isOSVersionLT(10);96 }97 } else if (Triple.isWatchOS()) {98 if (!Triple.isSimulatorEnvironment())99 this->TLSSupported = !Triple.isOSVersionLT(2);100 else101 this->TLSSupported = !Triple.isOSVersionLT(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 for117 // exception objects because of a bug in __cxa_exception that was118 // 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 == 64152 ? (IsSigned ? TargetInfo::SignedLongLong153 : TargetInfo::UnsignedLongLong)154 : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);155 }156 157 bool areDefaultedSMFStillPOD(const LangOptions &) const override {158 return false;159 }160};161 162// DragonFlyBSD Target163template <typename Target>164class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo165 : 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 output170 Builder.defineMacro("__DragonFly__");171 Builder.defineMacro("__DragonFly_cc_version", "100001");172 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");173 Builder.defineMacro("__tune_i386__");174 DefineStd(Builder, "unix", Opts);175 if (this->HasFloat128)176 Builder.defineMacro("__FLOAT128__");177 178 if (Opts.C11)179 Builder.defineMacro("__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_VERSION197#define FREEBSD_CC_VERSION 0U198#endif199 200// FreeBSD Target201template <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 output207 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("__FreeBSD__", Twine(Release));216 Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion));217 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");218 DefineStd(Builder, "unix", Opts);219 if (this->HasFloat128)220 Builder.defineMacro("__FLOAT128__");221 222 // On FreeBSD, wchar_t contains the number of the code point as223 // used by the character set of the locale. These character sets are224 // not necessarily a superset of ASCII.225 //226 // FIXME: This is wrong; the macro refers to the numerical values227 // of wchar_t *literals*, which are not locale-dependent. However,228 // FreeBSD systems apparently depend on us getting this wrong, and229 // setting this to 1 is conforming even if all the basic source230 // character literals have the same encoding as char and wchar_t.231 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "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 Target264template <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 output270 271 DefineStd(Builder, "unix", Opts);272 Builder.defineMacro("__FreeBSD_kernel__");273 Builder.defineMacro("__GLIBC__");274 if (Opts.POSIXThreads)275 Builder.defineMacro("_REENTRANT");276 if (Opts.CPlusPlus)277 Builder.defineMacro("_GNU_SOURCE");278 }279 280public:281 using OSTargetInfo<Target>::OSTargetInfo;282};283 284// Haiku Target285template <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 output291 Builder.defineMacro("__HAIKU__");292 DefineStd(Builder, "unix", Opts);293 if (this->HasFloat128)294 Builder.defineMacro("__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 target316template <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, "unix", Opts);323 Builder.defineMacro("__GNU__");324 Builder.defineMacro("__gnu_hurd__");325 Builder.defineMacro("__MACH__");326 Builder.defineMacro("__GLIBC__");327 if (Opts.POSIXThreads)328 Builder.defineMacro("_REENTRANT");329 if (Opts.CPlusPlus)330 Builder.defineMacro("_GNU_SOURCE");331 if (this->HasFloat128)332 Builder.defineMacro("__FLOAT128__");333 }334public:335 HurdTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)336 : OSTargetInfo<Target>(Triple, Opts) {337 switch (Triple.getArch()) {338 default:339 break;340 case llvm::Triple::x86:341 case llvm::Triple::x86_64:342 this->HasFloat128 = true;343 break;344 }345 }346};347 348// Linux target349template <typename Target>350class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {351protected:352 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,353 MacroBuilder &Builder) const override {354 // Linux defines; list based off of gcc output355 DefineStd(Builder, "unix", Opts);356 DefineStd(Builder, "linux", Opts);357 if (Triple.isAndroid()) {358 Builder.defineMacro("__ANDROID__", "1");359 this->PlatformName = "android";360 this->PlatformMinVersion = Triple.getEnvironmentVersion();361 const unsigned Maj = this->PlatformMinVersion.getMajor();362 if (Maj) {363 Builder.defineMacro("__ANDROID_MIN_SDK_VERSION__", Twine(Maj));364 // This historical but ambiguous name for the minSdkVersion macro. Keep365 // defined for compatibility.366 Builder.defineMacro("__ANDROID_API__", "__ANDROID_MIN_SDK_VERSION__");367 }368 } else {369 Builder.defineMacro("__gnu_linux__");370 }371 if (Opts.POSIXThreads)372 Builder.defineMacro("_REENTRANT");373 if (Opts.CPlusPlus)374 Builder.defineMacro("_GNU_SOURCE");375 if (this->HasFloat128)376 Builder.defineMacro("__FLOAT128__");377 if (Triple.isTime64ABI()) {378 Builder.defineMacro("_FILE_OFFSET_BITS", "64");379 Builder.defineMacro("_TIME_BITS", "64");380 }381 }382 383public:384 LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)385 : OSTargetInfo<Target>(Triple, Opts) {386 this->WIntType = TargetInfo::UnsignedInt;387 388 switch (Triple.getArch()) {389 default:390 break;391 case llvm::Triple::mips:392 case llvm::Triple::mipsel:393 case llvm::Triple::mips64:394 case llvm::Triple::mips64el:395 case llvm::Triple::ppc:396 case llvm::Triple::ppcle:397 case llvm::Triple::ppc64:398 case llvm::Triple::ppc64le:399 this->MCountName = "_mcount";400 break;401 case llvm::Triple::x86:402 case llvm::Triple::x86_64:403 this->HasFloat128 = true;404 break;405 }406 }407 408 const char *getStaticInitSectionSpecifier() const override {409 return ".text.startup";410 }411 412 // This allows template specializations, see413 // LinuxTargetInfo<AArch64leTargetInfo>::setABI414 bool setABI(const std::string &Name) override {415 return OSTargetInfo<Target>::setABI(Name);416 }417};418 419// Managarm Target420template <typename Target>421class LLVM_LIBRARY_VISIBILITY ManagarmTargetInfo : public OSTargetInfo<Target> {422protected:423 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,424 MacroBuilder &Builder) const override {425 DefineStd(Builder, "unix", Opts);426 Builder.defineMacro("__managarm__");427 if (Opts.POSIXThreads)428 Builder.defineMacro("_REENTRANT");429 if (Opts.CPlusPlus)430 Builder.defineMacro("_GNU_SOURCE");431 if (this->HasFloat128)432 Builder.defineMacro("__FLOAT128__");433 }434 435public:436 ManagarmTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)437 : OSTargetInfo<Target>(Triple, Opts) {438 switch (Triple.getArch()) {439 default:440 break;441 case llvm::Triple::x86:442 case llvm::Triple::x86_64:443 this->HasFloat128 = true;444 break;445 }446 }447};448 449// NetBSD Target450template <typename Target>451class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> {452protected:453 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,454 MacroBuilder &Builder) const override {455 // NetBSD defines; list based off of gcc output456 Builder.defineMacro("__NetBSD__");457 Builder.defineMacro("__unix__");458 if (Opts.POSIXThreads)459 Builder.defineMacro("_REENTRANT");460 if (this->HasFloat128)461 Builder.defineMacro("__FLOAT128__");462 }463 464public:465 NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)466 : OSTargetInfo<Target>(Triple, Opts) {467 this->MCountName = "__mcount";468 switch (Triple.getArch()) {469 default:470 break;471 case llvm::Triple::x86:472 case llvm::Triple::x86_64:473 this->HasFloat128 = true;474 break;475 }476 }477};478 479// OpenBSD Target480template <typename Target>481class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> {482protected:483 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,484 MacroBuilder &Builder) const override {485 // OpenBSD defines; list based off of gcc output486 487 Builder.defineMacro("__OpenBSD__");488 DefineStd(Builder, "unix", Opts);489 if (Opts.POSIXThreads)490 Builder.defineMacro("_REENTRANT");491 if (this->HasFloat128)492 Builder.defineMacro("__FLOAT128__");493 494 if (Opts.C11)495 Builder.defineMacro("__STDC_NO_THREADS__");496 }497 498public:499 OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)500 : OSTargetInfo<Target>(Triple, Opts) {501 this->WCharType = this->WIntType = this->SignedInt;502 this->IntMaxType = TargetInfo::SignedLongLong;503 this->Int64Type = TargetInfo::SignedLongLong;504 switch (Triple.getArch()) {505 case llvm::Triple::x86:506 case llvm::Triple::x86_64:507 this->HasFloat128 = true;508 [[fallthrough]];509 default:510 this->MCountName = "__mcount";511 break;512 case llvm::Triple::mips64:513 case llvm::Triple::mips64el:514 case llvm::Triple::ppc:515 case llvm::Triple::ppc64:516 case llvm::Triple::ppc64le:517 case llvm::Triple::sparcv9:518 this->MCountName = "_mcount";519 break;520 case llvm::Triple::loongarch64:521 case llvm::Triple::riscv64:522 break;523 }524 }525};526 527// PS3 PPU Target528template <typename Target>529class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> {530protected:531 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,532 MacroBuilder &Builder) const override {533 // PS3 PPU defines.534 Builder.defineMacro("__PPU__");535 Builder.defineMacro("__CELLOS_LV2__");536 Builder.defineMacro("__LP32__");537 Builder.defineMacro("_ARCH_PPC64");538 Builder.defineMacro("__powerpc64__");539 }540 541public:542 PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)543 : OSTargetInfo<Target>(Triple, Opts) {544 this->LongWidth = this->LongAlign = 32;545 this->PointerWidth = this->PointerAlign = 32;546 this->IntMaxType = TargetInfo::SignedLongLong;547 this->Int64Type = TargetInfo::SignedLongLong;548 this->SizeType = TargetInfo::UnsignedInt;549 this->resetDataLayout("E-m:e-p:32:32-Fi64-i64:64-i128:128-n32:64");550 }551};552 553// Common base class for PS4/PS5 targets.554template <typename Target>555class LLVM_LIBRARY_VISIBILITY PSOSTargetInfo : public OSTargetInfo<Target> {556protected:557 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,558 MacroBuilder &Builder) const override {559 Builder.defineMacro("__FreeBSD__", "9");560 Builder.defineMacro("__FreeBSD_cc_version", "900001");561 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");562 DefineStd(Builder, "unix", Opts);563 Builder.defineMacro("__SCE__");564 Builder.defineMacro("__STDC_NO_COMPLEX__");565 Builder.defineMacro("__STDC_NO_THREADS__");566 }567 568public:569 PSOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)570 : OSTargetInfo<Target>(Triple, Opts) {571 this->WCharType = TargetInfo::UnsignedShort;572 573 // On PS4/PS5, TLS variable cannot be aligned to more than 32 bytes (256574 // bits).575 this->MaxTLSAlign = 256;576 577 // On PS4/PS5, do not honor explicit bit field alignment,578 // as in "__attribute__((aligned(2))) int b : 1;".579 this->UseExplicitBitFieldAlignment = false;580 581 this->MCountName = ".mcount";582 this->NewAlign = 256;583 this->SuitableAlign = 256;584 }585 586 TargetInfo::CallingConvCheckResult587 checkCallingConvention(CallingConv CC) const override {588 return (CC == CC_C) ? TargetInfo::CCCR_OK : TargetInfo::CCCR_Error;589 }590 591 bool areDefaultedSMFStillPOD(const LangOptions &) const override {592 return false;593 }594};595 596// PS4 Target597template <typename Target>598class LLVM_LIBRARY_VISIBILITY PS4OSTargetInfo : public PSOSTargetInfo<Target> {599protected:600 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,601 MacroBuilder &Builder) const override {602 // Start with base class defines.603 PSOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);604 605 Builder.defineMacro("__ORBIS__");606 }607 608public:609 using PSOSTargetInfo<Target>::PSOSTargetInfo;610};611 612// PS5 Target613template <typename Target>614class LLVM_LIBRARY_VISIBILITY PS5OSTargetInfo : public PSOSTargetInfo<Target> {615protected:616 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,617 MacroBuilder &Builder) const override {618 // Start with base class defines.619 PSOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);620 621 Builder.defineMacro("__PROSPERO__");622 }623 624public:625 using PSOSTargetInfo<Target>::PSOSTargetInfo;626};627 628// RTEMS Target629template <typename Target>630class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> {631protected:632 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,633 MacroBuilder &Builder) const override {634 // RTEMS defines; list based off of gcc output635 636 Builder.defineMacro("__rtems__");637 if (Opts.CPlusPlus)638 Builder.defineMacro("_GNU_SOURCE");639 }640 641public:642 RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)643 : OSTargetInfo<Target>(Triple, Opts) {644 switch (Triple.getArch()) {645 default:646 case llvm::Triple::x86:647 // this->MCountName = ".mcount";648 break;649 case llvm::Triple::mips:650 case llvm::Triple::mipsel:651 case llvm::Triple::ppc:652 case llvm::Triple::ppc64:653 case llvm::Triple::ppc64le:654 // this->MCountName = "_mcount";655 break;656 case llvm::Triple::arm:657 // this->MCountName = "__mcount";658 break;659 }660 }661};662 663// Solaris target664template <typename Target>665class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> {666protected:667 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,668 MacroBuilder &Builder) const override {669 DefineStd(Builder, "sun", Opts);670 DefineStd(Builder, "unix", Opts);671 Builder.defineMacro("__svr4__");672 Builder.defineMacro("__SVR4");673 Builder.defineMacro("_XOPEN_SOURCE", "600");674 if (Opts.CPlusPlus) {675 Builder.defineMacro("__C99FEATURES__");676 Builder.defineMacro("_FILE_OFFSET_BITS", "64");677 }678 // GCC restricts the next two to C++.679 Builder.defineMacro("_LARGEFILE_SOURCE");680 Builder.defineMacro("_LARGEFILE64_SOURCE");681 Builder.defineMacro("__EXTENSIONS__");682 if (Opts.POSIXThreads)683 Builder.defineMacro("_REENTRANT");684 if (this->HasFloat128)685 Builder.defineMacro("__FLOAT128__");686 }687 688public:689 SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)690 : OSTargetInfo<Target>(Triple, Opts) {691 if (this->PointerWidth == 64) {692 this->WCharType = this->WIntType = this->SignedInt;693 } else {694 this->WCharType = this->WIntType = this->SignedLong;695 }696 switch (Triple.getArch()) {697 default:698 break;699 case llvm::Triple::x86:700 case llvm::Triple::x86_64:701 this->HasFloat128 = true;702 break;703 }704 }705};706 707// AIX Target708template <typename Target>709class AIXTargetInfo : public OSTargetInfo<Target> {710protected:711 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,712 MacroBuilder &Builder) const override {713 DefineStd(Builder, "unix", Opts);714 Builder.defineMacro("_IBMR2");715 Builder.defineMacro("_POWER");716 Builder.defineMacro("__THW_BIG_ENDIAN__");717 718 Builder.defineMacro("_AIX");719 Builder.defineMacro("__TOS_AIX__");720 Builder.defineMacro("__HOS_AIX__");721 722 if (Opts.C11) {723 Builder.defineMacro("__STDC_NO_ATOMICS__");724 Builder.defineMacro("__STDC_NO_THREADS__");725 }726 727 if (Opts.EnableAIXExtendedAltivecABI)728 Builder.defineMacro("__EXTABI__");729 730 VersionTuple OsVersion = Triple.getOSVersion();731 732 // Define AIX OS-Version Macros.733 // Includes logic for legacy versions of AIX; no specific intent to support.734 if (OsVersion >= VersionTuple(3, 2))735 Builder.defineMacro("_AIX32");736 if (OsVersion >= VersionTuple(4, 1))737 Builder.defineMacro("_AIX41");738 if (OsVersion >= VersionTuple(4, 3))739 Builder.defineMacro("_AIX43");740 if (OsVersion >= VersionTuple(5, 0))741 Builder.defineMacro("_AIX50");742 if (OsVersion >= VersionTuple(5, 1))743 Builder.defineMacro("_AIX51");744 if (OsVersion >= VersionTuple(5, 2))745 Builder.defineMacro("_AIX52");746 if (OsVersion >= VersionTuple(5, 3))747 Builder.defineMacro("_AIX53");748 if (OsVersion >= VersionTuple(6, 1))749 Builder.defineMacro("_AIX61");750 if (OsVersion >= VersionTuple(7, 1))751 Builder.defineMacro("_AIX71");752 if (OsVersion >= VersionTuple(7, 2))753 Builder.defineMacro("_AIX72");754 if (OsVersion >= VersionTuple(7, 3))755 Builder.defineMacro("_AIX73");756 757 // FIXME: Do not define _LONG_LONG when -fno-long-long is specified.758 Builder.defineMacro("_LONG_LONG");759 760 if (Opts.POSIXThreads) {761 Builder.defineMacro("_THREAD_SAFE");762 }763 764 if (this->PointerWidth == 64) {765 Builder.defineMacro("__64BIT__");766 }767 768 // Define _WCHAR_T when it is a fundamental type769 // (i.e., for C++ without -fno-wchar).770 if (Opts.CPlusPlus && Opts.WChar) {771 Builder.defineMacro("_WCHAR_T");772 }773 }774 775public:776 AIXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)777 : OSTargetInfo<Target>(Triple, Opts) {778 this->MCountName = "__mcount";779 this->TheCXXABI.set(TargetCXXABI::XL);780 781 if (this->PointerWidth == 64) {782 this->WCharType = this->UnsignedInt;783 } else {784 this->WCharType = this->UnsignedShort;785 }786 this->UseZeroLengthBitfieldAlignment = true;787 }788 789 // AIX sets FLT_EVAL_METHOD to be 1.790 LangOptions::FPEvalMethodKind getFPEvalMethod() const override {791 return LangOptions::FPEvalMethodKind::FEM_Double;792 }793 794 bool defaultsToAIXPowerAlignment() const override { return true; }795 796 bool areDefaultedSMFStillPOD(const LangOptions &) const override {797 return false;798 }799};800 801// z/OS target802template <typename Target>803class LLVM_LIBRARY_VISIBILITY ZOSTargetInfo : public OSTargetInfo<Target> {804protected:805 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,806 MacroBuilder &Builder) const override {807 // FIXME: _LONG_LONG should not be defined under -std=c89.808 Builder.defineMacro("_LONG_LONG");809 Builder.defineMacro("__370__");810 Builder.defineMacro("__BFP__");811 // FIXME: __BOOL__ should not be defined under -std=c89.812 Builder.defineMacro("__BOOL__");813 Builder.defineMacro("__COMPILER_VER__", "0x50000000");814 Builder.defineMacro("__LONGNAME__");815 Builder.defineMacro("__MVS__");816 Builder.defineMacro("__THW_370__");817 Builder.defineMacro("__THW_BIG_ENDIAN__");818 Builder.defineMacro("__TOS_390__");819 Builder.defineMacro("__TOS_MVS__");820 Builder.defineMacro("__XPLINK__");821 822 if (this->PointerWidth == 64)823 Builder.defineMacro("__64BIT__");824 825 if (Opts.CPlusPlus && Opts.WChar) {826 // Macro __wchar_t is defined so that the wchar_t data827 // type is not declared as a typedef in system headers.828 Builder.defineMacro("__wchar_t");829 }830 831 this->PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());832 }833 834public:835 ZOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)836 : OSTargetInfo<Target>(Triple, Opts) {837 this->WCharType = TargetInfo::UnsignedInt;838 this->MaxAlignedAttribute = 128;839 this->UseBitFieldTypeAlignment = false;840 this->UseZeroLengthBitfieldAlignment = true;841 this->UseLeadingZeroLengthBitfield = false;842 this->ZeroLengthBitfieldBoundary = 32;843 this->TheCXXABI.set(TargetCXXABI::XL);844 }845 846 bool areDefaultedSMFStillPOD(const LangOptions &) const override {847 return false;848 }849};850 851// UEFI target852template <typename Target>853class LLVM_LIBRARY_VISIBILITY UEFITargetInfo : public OSTargetInfo<Target> {854protected:855 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,856 MacroBuilder &Builder) const override {857 Builder.defineMacro("__UEFI__");858 }859 860public:861 UEFITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)862 : OSTargetInfo<Target>(Triple, Opts) {863 this->WCharType = TargetInfo::UnsignedShort;864 this->WIntType = TargetInfo::UnsignedShort;865 this->UseMicrosoftManglingForC = true;866 }867};868 869void addWindowsDefines(const llvm::Triple &Triple, const LangOptions &Opts,870 MacroBuilder &Builder);871 872// Windows target873template <typename Target>874class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> {875protected:876 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,877 MacroBuilder &Builder) const override {878 addWindowsDefines(Triple, Opts, Builder);879 }880 881public:882 WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)883 : OSTargetInfo<Target>(Triple, Opts) {884 this->WCharType = TargetInfo::UnsignedShort;885 this->WIntType = TargetInfo::UnsignedShort;886 this->UseMicrosoftManglingForC = true;887 }888};889 890// Fuchsia Target891template <typename Target>892class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> {893protected:894 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,895 MacroBuilder &Builder) const override {896 Builder.defineMacro("__Fuchsia__");897 if (Opts.POSIXThreads)898 Builder.defineMacro("_REENTRANT");899 // Required by the libc++ locale support.900 if (Opts.CPlusPlus)901 Builder.defineMacro("_GNU_SOURCE");902 Builder.defineMacro("__Fuchsia_API_level__", Twine(Opts.FuchsiaAPILevel));903 this->PlatformName = "fuchsia";904 this->PlatformMinVersion = VersionTuple(Opts.FuchsiaAPILevel);905 }906 907public:908 FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)909 : OSTargetInfo<Target>(Triple, Opts) {910 this->WIntType = TargetInfo::UnsignedInt;911 this->MCountName = "__mcount";912 this->TheCXXABI.set(TargetCXXABI::Fuchsia);913 }914};915 916// WebAssembly target917template <typename Target>918class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo919 : public OSTargetInfo<Target> {920protected:921 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,922 MacroBuilder &Builder) const override {923 // A common platform macro.924 if (Opts.POSIXThreads)925 Builder.defineMacro("_REENTRANT");926 // Follow g++ convention and predefine _GNU_SOURCE for C++.927 if (Opts.CPlusPlus)928 Builder.defineMacro("_GNU_SOURCE");929 // Indicate that we have __float128.930 Builder.defineMacro("__FLOAT128__");931 }932 933public:934 explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple,935 const TargetOptions &Opts)936 : OSTargetInfo<Target>(Triple, Opts) {937 this->MCountName = "__mcount";938 this->TheCXXABI.set(TargetCXXABI::WebAssembly);939 this->HasFloat128 = true;940 }941};942 943// WASI target944template <typename Target>945class LLVM_LIBRARY_VISIBILITY WASITargetInfo946 : public WebAssemblyOSTargetInfo<Target> {947 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,948 MacroBuilder &Builder) const final {949 WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);950 Builder.defineMacro("__wasi__");951 }952 953public:954 using WebAssemblyOSTargetInfo<Target>::WebAssemblyOSTargetInfo;955};956 957// WALI target958template <typename Target>959class LLVM_LIBRARY_VISIBILITY WALITargetInfo960 : public WebAssemblyOSTargetInfo<Target> {961 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,962 MacroBuilder &Builder) const final {963 WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);964 // Linux defines; list based off of gcc output965 DefineStd(Builder, "unix", Opts);966 DefineStd(Builder, "linux", Opts);967 Builder.defineMacro("__wali__");968 }969 970public:971 using WebAssemblyOSTargetInfo<Target>::WebAssemblyOSTargetInfo;972};973 974// Emscripten target975template <typename Target>976class LLVM_LIBRARY_VISIBILITY EmscriptenTargetInfo977 : public WebAssemblyOSTargetInfo<Target> {978 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,979 MacroBuilder &Builder) const final {980 WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder);981 DefineStd(Builder, "unix", Opts);982 Builder.defineMacro("__EMSCRIPTEN__");983 if (Opts.POSIXThreads)984 Builder.defineMacro("__EMSCRIPTEN_PTHREADS__");985 }986 987public:988 explicit EmscriptenTargetInfo(const llvm::Triple &Triple,989 const TargetOptions &Opts)990 : WebAssemblyOSTargetInfo<Target>(Triple, Opts) {991 // Keeping the alignment of long double to 8 bytes even though its size is992 // 16 bytes allows emscripten to have an 8-byte-aligned max_align_t which993 // in turn gives is a 8-byte aligned malloc.994 // Emscripten's ABI is unstable and we may change this back to 128 to match995 // the WebAssembly default in the future.996 this->LongDoubleAlign = 64;997 this->Float128Align = 64;998 }999};1000 1001// OHOS target1002template <typename Target>1003class LLVM_LIBRARY_VISIBILITY OHOSTargetInfo : public OSTargetInfo<Target> {1004protected:1005 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,1006 MacroBuilder &Builder) const override {1007 // Linux defines; list based off of gcc output1008 DefineStd(Builder, "unix", Opts);1009 1010 // Generic OHOS target defines1011 if (Triple.isOHOSFamily()) {1012 Builder.defineMacro("__OHOS_FAMILY__", "1");1013 1014 auto Version = Triple.getEnvironmentVersion();1015 this->PlatformName = "ohos";1016 this->PlatformMinVersion = Version;1017 Builder.defineMacro("__OHOS_Major__", Twine(Version.getMajor()));1018 if (auto Minor = Version.getMinor())1019 Builder.defineMacro("__OHOS_Minor__", Twine(*Minor));1020 if (auto Subminor = Version.getSubminor())1021 Builder.defineMacro("__OHOS_Micro__", Twine(*Subminor));1022 }1023 1024 if (Triple.isOpenHOS())1025 Builder.defineMacro("__OHOS__");1026 1027 if (Triple.isOSLinux()) {1028 DefineStd(Builder, "linux", Opts);1029 } else if (Triple.isOSLiteOS()) {1030 Builder.defineMacro("__LITEOS__");1031 }1032 1033 if (Opts.POSIXThreads)1034 Builder.defineMacro("_REENTRANT");1035 if (Opts.CPlusPlus)1036 Builder.defineMacro("_GNU_SOURCE");1037 if (this->HasFloat128)1038 Builder.defineMacro("__FLOAT128__");1039 }1040 1041public:1042 OHOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)1043 : OSTargetInfo<Target>(Triple, Opts) {1044 this->WIntType = TargetInfo::UnsignedInt;1045 1046 switch (Triple.getArch()) {1047 default:1048 break;1049 case llvm::Triple::x86:1050 case llvm::Triple::x86_64:1051 this->HasFloat128 = true;1052 break;1053 }1054 }1055 1056 const char *getStaticInitSectionSpecifier() const override {1057 return ".text.startup";1058 }1059};1060 1061} // namespace targets1062} // namespace clang1063#endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H1064