1*06f32e7eSjoerg //===--- OSTargets.h - Declare OS target feature support --------*- C++ -*-===// 2*06f32e7eSjoerg // 3*06f32e7eSjoerg // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4*06f32e7eSjoerg // See https://llvm.org/LICENSE.txt for license information. 5*06f32e7eSjoerg // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6*06f32e7eSjoerg // 7*06f32e7eSjoerg //===----------------------------------------------------------------------===// 8*06f32e7eSjoerg // 9*06f32e7eSjoerg // This file declares OS specific TargetInfo types. 10*06f32e7eSjoerg //===----------------------------------------------------------------------===// 11*06f32e7eSjoerg 12*06f32e7eSjoerg #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H 13*06f32e7eSjoerg #define LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H 14*06f32e7eSjoerg 15*06f32e7eSjoerg #include "Targets.h" 16*06f32e7eSjoerg #include "llvm/MC/MCSectionMachO.h" 17*06f32e7eSjoerg 18*06f32e7eSjoerg namespace clang { 19*06f32e7eSjoerg namespace targets { 20*06f32e7eSjoerg 21*06f32e7eSjoerg template <typename TgtInfo> 22*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY OSTargetInfo : public TgtInfo { 23*06f32e7eSjoerg protected: 24*06f32e7eSjoerg virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 25*06f32e7eSjoerg MacroBuilder &Builder) const = 0; 26*06f32e7eSjoerg 27*06f32e7eSjoerg public: 28*06f32e7eSjoerg OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 29*06f32e7eSjoerg : TgtInfo(Triple, Opts) {} 30*06f32e7eSjoerg 31*06f32e7eSjoerg void getTargetDefines(const LangOptions &Opts, 32*06f32e7eSjoerg MacroBuilder &Builder) const override { 33*06f32e7eSjoerg TgtInfo::getTargetDefines(Opts, Builder); 34*06f32e7eSjoerg getOSDefines(Opts, TgtInfo::getTriple(), Builder); 35*06f32e7eSjoerg } 36*06f32e7eSjoerg }; 37*06f32e7eSjoerg 38*06f32e7eSjoerg // CloudABI Target 39*06f32e7eSjoerg template <typename Target> 40*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY CloudABITargetInfo : public OSTargetInfo<Target> { 41*06f32e7eSjoerg protected: 42*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 43*06f32e7eSjoerg MacroBuilder &Builder) const override { 44*06f32e7eSjoerg Builder.defineMacro("__CloudABI__"); 45*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 46*06f32e7eSjoerg 47*06f32e7eSjoerg // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t. 48*06f32e7eSjoerg Builder.defineMacro("__STDC_ISO_10646__", "201206L"); 49*06f32e7eSjoerg Builder.defineMacro("__STDC_UTF_16__"); 50*06f32e7eSjoerg Builder.defineMacro("__STDC_UTF_32__"); 51*06f32e7eSjoerg } 52*06f32e7eSjoerg 53*06f32e7eSjoerg public: 54*06f32e7eSjoerg CloudABITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 55*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) {} 56*06f32e7eSjoerg }; 57*06f32e7eSjoerg 58*06f32e7eSjoerg // Ananas target 59*06f32e7eSjoerg template <typename Target> 60*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY AnanasTargetInfo : public OSTargetInfo<Target> { 61*06f32e7eSjoerg protected: 62*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 63*06f32e7eSjoerg MacroBuilder &Builder) const override { 64*06f32e7eSjoerg // Ananas defines 65*06f32e7eSjoerg Builder.defineMacro("__Ananas__"); 66*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 67*06f32e7eSjoerg } 68*06f32e7eSjoerg 69*06f32e7eSjoerg public: 70*06f32e7eSjoerg AnanasTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 71*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) {} 72*06f32e7eSjoerg }; 73*06f32e7eSjoerg 74*06f32e7eSjoerg void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, 75*06f32e7eSjoerg const llvm::Triple &Triple, StringRef &PlatformName, 76*06f32e7eSjoerg VersionTuple &PlatformMinVersion); 77*06f32e7eSjoerg 78*06f32e7eSjoerg template <typename Target> 79*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY DarwinTargetInfo : public OSTargetInfo<Target> { 80*06f32e7eSjoerg protected: 81*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 82*06f32e7eSjoerg MacroBuilder &Builder) const override { 83*06f32e7eSjoerg getDarwinDefines(Builder, Opts, Triple, this->PlatformName, 84*06f32e7eSjoerg this->PlatformMinVersion); 85*06f32e7eSjoerg } 86*06f32e7eSjoerg 87*06f32e7eSjoerg public: 88*06f32e7eSjoerg DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 89*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 90*06f32e7eSjoerg // By default, no TLS, and we whitelist permitted architecture/OS 91*06f32e7eSjoerg // combinations. 92*06f32e7eSjoerg this->TLSSupported = false; 93*06f32e7eSjoerg 94*06f32e7eSjoerg if (Triple.isMacOSX()) 95*06f32e7eSjoerg this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7); 96*06f32e7eSjoerg else if (Triple.isiOS()) { 97*06f32e7eSjoerg // 64-bit iOS supported it from 8 onwards, 32-bit device from 9 onwards, 98*06f32e7eSjoerg // 32-bit simulator from 10 onwards. 99*06f32e7eSjoerg if (Triple.isArch64Bit()) 100*06f32e7eSjoerg this->TLSSupported = !Triple.isOSVersionLT(8); 101*06f32e7eSjoerg else if (Triple.isArch32Bit()) { 102*06f32e7eSjoerg if (!Triple.isSimulatorEnvironment()) 103*06f32e7eSjoerg this->TLSSupported = !Triple.isOSVersionLT(9); 104*06f32e7eSjoerg else 105*06f32e7eSjoerg this->TLSSupported = !Triple.isOSVersionLT(10); 106*06f32e7eSjoerg } 107*06f32e7eSjoerg } else if (Triple.isWatchOS()) { 108*06f32e7eSjoerg if (!Triple.isSimulatorEnvironment()) 109*06f32e7eSjoerg this->TLSSupported = !Triple.isOSVersionLT(2); 110*06f32e7eSjoerg else 111*06f32e7eSjoerg this->TLSSupported = !Triple.isOSVersionLT(3); 112*06f32e7eSjoerg } 113*06f32e7eSjoerg 114*06f32e7eSjoerg this->MCountName = "\01mcount"; 115*06f32e7eSjoerg } 116*06f32e7eSjoerg 117*06f32e7eSjoerg std::string isValidSectionSpecifier(StringRef SR) const override { 118*06f32e7eSjoerg // Let MCSectionMachO validate this. 119*06f32e7eSjoerg StringRef Segment, Section; 120*06f32e7eSjoerg unsigned TAA, StubSize; 121*06f32e7eSjoerg bool HasTAA; 122*06f32e7eSjoerg return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section, 123*06f32e7eSjoerg TAA, HasTAA, StubSize); 124*06f32e7eSjoerg } 125*06f32e7eSjoerg 126*06f32e7eSjoerg const char *getStaticInitSectionSpecifier() const override { 127*06f32e7eSjoerg // FIXME: We should return 0 when building kexts. 128*06f32e7eSjoerg return "__TEXT,__StaticInit,regular,pure_instructions"; 129*06f32e7eSjoerg } 130*06f32e7eSjoerg 131*06f32e7eSjoerg /// Darwin does not support protected visibility. Darwin's "default" 132*06f32e7eSjoerg /// is very similar to ELF's "protected"; Darwin requires a "weak" 133*06f32e7eSjoerg /// attribute on declarations that can be dynamically replaced. 134*06f32e7eSjoerg bool hasProtectedVisibility() const override { return false; } 135*06f32e7eSjoerg 136*06f32e7eSjoerg unsigned getExnObjectAlignment() const override { 137*06f32e7eSjoerg // Older versions of libc++abi guarantee an alignment of only 8-bytes for 138*06f32e7eSjoerg // exception objects because of a bug in __cxa_exception that was 139*06f32e7eSjoerg // eventually fixed in r319123. 140*06f32e7eSjoerg llvm::VersionTuple MinVersion; 141*06f32e7eSjoerg const llvm::Triple &T = this->getTriple(); 142*06f32e7eSjoerg 143*06f32e7eSjoerg // Compute the earliest OS versions that have the fix to libc++abi. 144*06f32e7eSjoerg switch (T.getOS()) { 145*06f32e7eSjoerg case llvm::Triple::Darwin: 146*06f32e7eSjoerg case llvm::Triple::MacOSX: // Earliest supporting version is 10.14. 147*06f32e7eSjoerg MinVersion = llvm::VersionTuple(10U, 14U); 148*06f32e7eSjoerg break; 149*06f32e7eSjoerg case llvm::Triple::IOS: 150*06f32e7eSjoerg case llvm::Triple::TvOS: // Earliest supporting version is 12.0.0. 151*06f32e7eSjoerg MinVersion = llvm::VersionTuple(12U); 152*06f32e7eSjoerg break; 153*06f32e7eSjoerg case llvm::Triple::WatchOS: // Earliest supporting version is 5.0.0. 154*06f32e7eSjoerg MinVersion = llvm::VersionTuple(5U); 155*06f32e7eSjoerg break; 156*06f32e7eSjoerg default: 157*06f32e7eSjoerg llvm_unreachable("Unexpected OS"); 158*06f32e7eSjoerg } 159*06f32e7eSjoerg 160*06f32e7eSjoerg unsigned Major, Minor, Micro; 161*06f32e7eSjoerg T.getOSVersion(Major, Minor, Micro); 162*06f32e7eSjoerg if (llvm::VersionTuple(Major, Minor, Micro) < MinVersion) 163*06f32e7eSjoerg return 64; 164*06f32e7eSjoerg return OSTargetInfo<Target>::getExnObjectAlignment(); 165*06f32e7eSjoerg } 166*06f32e7eSjoerg 167*06f32e7eSjoerg TargetInfo::IntType getLeastIntTypeByWidth(unsigned BitWidth, 168*06f32e7eSjoerg bool IsSigned) const final { 169*06f32e7eSjoerg // Darwin uses `long long` for `int_least64_t` and `int_fast64_t`. 170*06f32e7eSjoerg return BitWidth == 64 171*06f32e7eSjoerg ? (IsSigned ? TargetInfo::SignedLongLong 172*06f32e7eSjoerg : TargetInfo::UnsignedLongLong) 173*06f32e7eSjoerg : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned); 174*06f32e7eSjoerg } 175*06f32e7eSjoerg }; 176*06f32e7eSjoerg 177*06f32e7eSjoerg // DragonFlyBSD Target 178*06f32e7eSjoerg template <typename Target> 179*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo 180*06f32e7eSjoerg : public OSTargetInfo<Target> { 181*06f32e7eSjoerg protected: 182*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 183*06f32e7eSjoerg MacroBuilder &Builder) const override { 184*06f32e7eSjoerg // DragonFly defines; list based off of gcc output 185*06f32e7eSjoerg Builder.defineMacro("__DragonFly__"); 186*06f32e7eSjoerg Builder.defineMacro("__DragonFly_cc_version", "100001"); 187*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 188*06f32e7eSjoerg Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 189*06f32e7eSjoerg Builder.defineMacro("__tune_i386__"); 190*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 191*06f32e7eSjoerg } 192*06f32e7eSjoerg 193*06f32e7eSjoerg public: 194*06f32e7eSjoerg DragonFlyBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 195*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 196*06f32e7eSjoerg switch (Triple.getArch()) { 197*06f32e7eSjoerg default: 198*06f32e7eSjoerg case llvm::Triple::x86: 199*06f32e7eSjoerg case llvm::Triple::x86_64: 200*06f32e7eSjoerg this->MCountName = ".mcount"; 201*06f32e7eSjoerg break; 202*06f32e7eSjoerg } 203*06f32e7eSjoerg } 204*06f32e7eSjoerg }; 205*06f32e7eSjoerg 206*06f32e7eSjoerg #ifndef FREEBSD_CC_VERSION 207*06f32e7eSjoerg #define FREEBSD_CC_VERSION 0U 208*06f32e7eSjoerg #endif 209*06f32e7eSjoerg 210*06f32e7eSjoerg // FreeBSD Target 211*06f32e7eSjoerg template <typename Target> 212*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY FreeBSDTargetInfo : public OSTargetInfo<Target> { 213*06f32e7eSjoerg protected: 214*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 215*06f32e7eSjoerg MacroBuilder &Builder) const override { 216*06f32e7eSjoerg // FreeBSD defines; list based off of gcc output 217*06f32e7eSjoerg 218*06f32e7eSjoerg unsigned Release = Triple.getOSMajorVersion(); 219*06f32e7eSjoerg if (Release == 0U) 220*06f32e7eSjoerg Release = 8U; 221*06f32e7eSjoerg unsigned CCVersion = FREEBSD_CC_VERSION; 222*06f32e7eSjoerg if (CCVersion == 0U) 223*06f32e7eSjoerg CCVersion = Release * 100000U + 1U; 224*06f32e7eSjoerg 225*06f32e7eSjoerg Builder.defineMacro("__FreeBSD__", Twine(Release)); 226*06f32e7eSjoerg Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion)); 227*06f32e7eSjoerg Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 228*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 229*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 230*06f32e7eSjoerg 231*06f32e7eSjoerg // On FreeBSD, wchar_t contains the number of the code point as 232*06f32e7eSjoerg // used by the character set of the locale. These character sets are 233*06f32e7eSjoerg // not necessarily a superset of ASCII. 234*06f32e7eSjoerg // 235*06f32e7eSjoerg // FIXME: This is wrong; the macro refers to the numerical values 236*06f32e7eSjoerg // of wchar_t *literals*, which are not locale-dependent. However, 237*06f32e7eSjoerg // FreeBSD systems apparently depend on us getting this wrong, and 238*06f32e7eSjoerg // setting this to 1 is conforming even if all the basic source 239*06f32e7eSjoerg // character literals have the same encoding as char and wchar_t. 240*06f32e7eSjoerg Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1"); 241*06f32e7eSjoerg } 242*06f32e7eSjoerg 243*06f32e7eSjoerg public: 244*06f32e7eSjoerg FreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 245*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 246*06f32e7eSjoerg switch (Triple.getArch()) { 247*06f32e7eSjoerg default: 248*06f32e7eSjoerg case llvm::Triple::x86: 249*06f32e7eSjoerg case llvm::Triple::x86_64: 250*06f32e7eSjoerg this->MCountName = ".mcount"; 251*06f32e7eSjoerg break; 252*06f32e7eSjoerg case llvm::Triple::mips: 253*06f32e7eSjoerg case llvm::Triple::mipsel: 254*06f32e7eSjoerg case llvm::Triple::ppc: 255*06f32e7eSjoerg case llvm::Triple::ppc64: 256*06f32e7eSjoerg case llvm::Triple::ppc64le: 257*06f32e7eSjoerg this->MCountName = "_mcount"; 258*06f32e7eSjoerg break; 259*06f32e7eSjoerg case llvm::Triple::arm: 260*06f32e7eSjoerg this->MCountName = "__mcount"; 261*06f32e7eSjoerg break; 262*06f32e7eSjoerg } 263*06f32e7eSjoerg } 264*06f32e7eSjoerg }; 265*06f32e7eSjoerg 266*06f32e7eSjoerg // GNU/kFreeBSD Target 267*06f32e7eSjoerg template <typename Target> 268*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY KFreeBSDTargetInfo : public OSTargetInfo<Target> { 269*06f32e7eSjoerg protected: 270*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 271*06f32e7eSjoerg MacroBuilder &Builder) const override { 272*06f32e7eSjoerg // GNU/kFreeBSD defines; list based off of gcc output 273*06f32e7eSjoerg 274*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 275*06f32e7eSjoerg Builder.defineMacro("__FreeBSD_kernel__"); 276*06f32e7eSjoerg Builder.defineMacro("__GLIBC__"); 277*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 278*06f32e7eSjoerg if (Opts.POSIXThreads) 279*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 280*06f32e7eSjoerg if (Opts.CPlusPlus) 281*06f32e7eSjoerg Builder.defineMacro("_GNU_SOURCE"); 282*06f32e7eSjoerg } 283*06f32e7eSjoerg 284*06f32e7eSjoerg public: 285*06f32e7eSjoerg KFreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 286*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) {} 287*06f32e7eSjoerg }; 288*06f32e7eSjoerg 289*06f32e7eSjoerg // Haiku Target 290*06f32e7eSjoerg template <typename Target> 291*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> { 292*06f32e7eSjoerg protected: 293*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 294*06f32e7eSjoerg MacroBuilder &Builder) const override { 295*06f32e7eSjoerg // Haiku defines; list based off of gcc output 296*06f32e7eSjoerg Builder.defineMacro("__HAIKU__"); 297*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 298*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 299*06f32e7eSjoerg if (this->HasFloat128) 300*06f32e7eSjoerg Builder.defineMacro("__FLOAT128__"); 301*06f32e7eSjoerg } 302*06f32e7eSjoerg 303*06f32e7eSjoerg public: 304*06f32e7eSjoerg HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 305*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 306*06f32e7eSjoerg this->SizeType = TargetInfo::UnsignedLong; 307*06f32e7eSjoerg this->IntPtrType = TargetInfo::SignedLong; 308*06f32e7eSjoerg this->PtrDiffType = TargetInfo::SignedLong; 309*06f32e7eSjoerg this->ProcessIDType = TargetInfo::SignedLong; 310*06f32e7eSjoerg this->TLSSupported = false; 311*06f32e7eSjoerg switch (Triple.getArch()) { 312*06f32e7eSjoerg default: 313*06f32e7eSjoerg break; 314*06f32e7eSjoerg case llvm::Triple::x86: 315*06f32e7eSjoerg case llvm::Triple::x86_64: 316*06f32e7eSjoerg this->HasFloat128 = true; 317*06f32e7eSjoerg break; 318*06f32e7eSjoerg } 319*06f32e7eSjoerg } 320*06f32e7eSjoerg }; 321*06f32e7eSjoerg 322*06f32e7eSjoerg // Hurd target 323*06f32e7eSjoerg template <typename Target> 324*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY HurdTargetInfo : public OSTargetInfo<Target> { 325*06f32e7eSjoerg protected: 326*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 327*06f32e7eSjoerg MacroBuilder &Builder) const override { 328*06f32e7eSjoerg // Hurd defines; list based off of gcc output. 329*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 330*06f32e7eSjoerg Builder.defineMacro("__GNU__"); 331*06f32e7eSjoerg Builder.defineMacro("__gnu_hurd__"); 332*06f32e7eSjoerg Builder.defineMacro("__MACH__"); 333*06f32e7eSjoerg Builder.defineMacro("__GLIBC__"); 334*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 335*06f32e7eSjoerg if (Opts.POSIXThreads) 336*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 337*06f32e7eSjoerg if (Opts.CPlusPlus) 338*06f32e7eSjoerg Builder.defineMacro("_GNU_SOURCE"); 339*06f32e7eSjoerg } 340*06f32e7eSjoerg public: 341*06f32e7eSjoerg HurdTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 342*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) {} 343*06f32e7eSjoerg }; 344*06f32e7eSjoerg 345*06f32e7eSjoerg // Minix Target 346*06f32e7eSjoerg template <typename Target> 347*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY MinixTargetInfo : public OSTargetInfo<Target> { 348*06f32e7eSjoerg protected: 349*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 350*06f32e7eSjoerg MacroBuilder &Builder) const override { 351*06f32e7eSjoerg // Minix defines 352*06f32e7eSjoerg 353*06f32e7eSjoerg Builder.defineMacro("__minix", "3"); 354*06f32e7eSjoerg Builder.defineMacro("_EM_WSIZE", "4"); 355*06f32e7eSjoerg Builder.defineMacro("_EM_PSIZE", "4"); 356*06f32e7eSjoerg Builder.defineMacro("_EM_SSIZE", "2"); 357*06f32e7eSjoerg Builder.defineMacro("_EM_LSIZE", "4"); 358*06f32e7eSjoerg Builder.defineMacro("_EM_FSIZE", "4"); 359*06f32e7eSjoerg Builder.defineMacro("_EM_DSIZE", "8"); 360*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 361*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 362*06f32e7eSjoerg } 363*06f32e7eSjoerg 364*06f32e7eSjoerg public: 365*06f32e7eSjoerg MinixTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 366*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) {} 367*06f32e7eSjoerg }; 368*06f32e7eSjoerg 369*06f32e7eSjoerg // Linux target 370*06f32e7eSjoerg template <typename Target> 371*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> { 372*06f32e7eSjoerg protected: 373*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 374*06f32e7eSjoerg MacroBuilder &Builder) const override { 375*06f32e7eSjoerg // Linux defines; list based off of gcc output 376*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 377*06f32e7eSjoerg DefineStd(Builder, "linux", Opts); 378*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 379*06f32e7eSjoerg if (Triple.isAndroid()) { 380*06f32e7eSjoerg Builder.defineMacro("__ANDROID__", "1"); 381*06f32e7eSjoerg unsigned Maj, Min, Rev; 382*06f32e7eSjoerg Triple.getEnvironmentVersion(Maj, Min, Rev); 383*06f32e7eSjoerg this->PlatformName = "android"; 384*06f32e7eSjoerg this->PlatformMinVersion = VersionTuple(Maj, Min, Rev); 385*06f32e7eSjoerg if (Maj) 386*06f32e7eSjoerg Builder.defineMacro("__ANDROID_API__", Twine(Maj)); 387*06f32e7eSjoerg } else { 388*06f32e7eSjoerg Builder.defineMacro("__gnu_linux__"); 389*06f32e7eSjoerg } 390*06f32e7eSjoerg if (Opts.POSIXThreads) 391*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 392*06f32e7eSjoerg if (Opts.CPlusPlus) 393*06f32e7eSjoerg Builder.defineMacro("_GNU_SOURCE"); 394*06f32e7eSjoerg if (this->HasFloat128) 395*06f32e7eSjoerg Builder.defineMacro("__FLOAT128__"); 396*06f32e7eSjoerg } 397*06f32e7eSjoerg 398*06f32e7eSjoerg public: 399*06f32e7eSjoerg LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 400*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 401*06f32e7eSjoerg this->WIntType = TargetInfo::UnsignedInt; 402*06f32e7eSjoerg 403*06f32e7eSjoerg switch (Triple.getArch()) { 404*06f32e7eSjoerg default: 405*06f32e7eSjoerg break; 406*06f32e7eSjoerg case llvm::Triple::mips: 407*06f32e7eSjoerg case llvm::Triple::mipsel: 408*06f32e7eSjoerg case llvm::Triple::mips64: 409*06f32e7eSjoerg case llvm::Triple::mips64el: 410*06f32e7eSjoerg case llvm::Triple::ppc: 411*06f32e7eSjoerg case llvm::Triple::ppc64: 412*06f32e7eSjoerg case llvm::Triple::ppc64le: 413*06f32e7eSjoerg this->MCountName = "_mcount"; 414*06f32e7eSjoerg break; 415*06f32e7eSjoerg case llvm::Triple::x86: 416*06f32e7eSjoerg case llvm::Triple::x86_64: 417*06f32e7eSjoerg this->HasFloat128 = true; 418*06f32e7eSjoerg break; 419*06f32e7eSjoerg } 420*06f32e7eSjoerg } 421*06f32e7eSjoerg 422*06f32e7eSjoerg const char *getStaticInitSectionSpecifier() const override { 423*06f32e7eSjoerg return ".text.startup"; 424*06f32e7eSjoerg } 425*06f32e7eSjoerg }; 426*06f32e7eSjoerg 427*06f32e7eSjoerg // NetBSD Target 428*06f32e7eSjoerg template <typename Target> 429*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> { 430*06f32e7eSjoerg protected: 431*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 432*06f32e7eSjoerg MacroBuilder &Builder) const override { 433*06f32e7eSjoerg // NetBSD defines; list based off of gcc output 434*06f32e7eSjoerg Builder.defineMacro("__NetBSD__"); 435*06f32e7eSjoerg Builder.defineMacro("__unix__"); 436*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 437*06f32e7eSjoerg if (Opts.POSIXThreads) 438*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 439*06f32e7eSjoerg } 440*06f32e7eSjoerg 441*06f32e7eSjoerg public: 442*06f32e7eSjoerg NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 443*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 444*06f32e7eSjoerg this->MCountName = "__mcount"; 445*06f32e7eSjoerg } 446*06f32e7eSjoerg }; 447*06f32e7eSjoerg 448*06f32e7eSjoerg // OpenBSD Target 449*06f32e7eSjoerg template <typename Target> 450*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> { 451*06f32e7eSjoerg protected: 452*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 453*06f32e7eSjoerg MacroBuilder &Builder) const override { 454*06f32e7eSjoerg // OpenBSD defines; list based off of gcc output 455*06f32e7eSjoerg 456*06f32e7eSjoerg Builder.defineMacro("__OpenBSD__"); 457*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 458*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 459*06f32e7eSjoerg if (Opts.POSIXThreads) 460*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 461*06f32e7eSjoerg if (this->HasFloat128) 462*06f32e7eSjoerg Builder.defineMacro("__FLOAT128__"); 463*06f32e7eSjoerg } 464*06f32e7eSjoerg 465*06f32e7eSjoerg public: 466*06f32e7eSjoerg OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 467*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 468*06f32e7eSjoerg switch (Triple.getArch()) { 469*06f32e7eSjoerg case llvm::Triple::x86: 470*06f32e7eSjoerg case llvm::Triple::x86_64: 471*06f32e7eSjoerg this->HasFloat128 = true; 472*06f32e7eSjoerg LLVM_FALLTHROUGH; 473*06f32e7eSjoerg default: 474*06f32e7eSjoerg this->MCountName = "__mcount"; 475*06f32e7eSjoerg break; 476*06f32e7eSjoerg case llvm::Triple::mips64: 477*06f32e7eSjoerg case llvm::Triple::mips64el: 478*06f32e7eSjoerg case llvm::Triple::ppc: 479*06f32e7eSjoerg case llvm::Triple::sparcv9: 480*06f32e7eSjoerg this->MCountName = "_mcount"; 481*06f32e7eSjoerg break; 482*06f32e7eSjoerg } 483*06f32e7eSjoerg } 484*06f32e7eSjoerg }; 485*06f32e7eSjoerg 486*06f32e7eSjoerg // PSP Target 487*06f32e7eSjoerg template <typename Target> 488*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY PSPTargetInfo : public OSTargetInfo<Target> { 489*06f32e7eSjoerg protected: 490*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 491*06f32e7eSjoerg MacroBuilder &Builder) const override { 492*06f32e7eSjoerg // PSP defines; list based on the output of the pspdev gcc toolchain. 493*06f32e7eSjoerg Builder.defineMacro("PSP"); 494*06f32e7eSjoerg Builder.defineMacro("_PSP"); 495*06f32e7eSjoerg Builder.defineMacro("__psp__"); 496*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 497*06f32e7eSjoerg } 498*06f32e7eSjoerg 499*06f32e7eSjoerg public: 500*06f32e7eSjoerg PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {} 501*06f32e7eSjoerg }; 502*06f32e7eSjoerg 503*06f32e7eSjoerg // PS3 PPU Target 504*06f32e7eSjoerg template <typename Target> 505*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> { 506*06f32e7eSjoerg protected: 507*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 508*06f32e7eSjoerg MacroBuilder &Builder) const override { 509*06f32e7eSjoerg // PS3 PPU defines. 510*06f32e7eSjoerg Builder.defineMacro("__PPC__"); 511*06f32e7eSjoerg Builder.defineMacro("__PPU__"); 512*06f32e7eSjoerg Builder.defineMacro("__CELLOS_LV2__"); 513*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 514*06f32e7eSjoerg Builder.defineMacro("__LP32__"); 515*06f32e7eSjoerg Builder.defineMacro("_ARCH_PPC64"); 516*06f32e7eSjoerg Builder.defineMacro("__powerpc64__"); 517*06f32e7eSjoerg } 518*06f32e7eSjoerg 519*06f32e7eSjoerg public: 520*06f32e7eSjoerg PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 521*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 522*06f32e7eSjoerg this->LongWidth = this->LongAlign = 32; 523*06f32e7eSjoerg this->PointerWidth = this->PointerAlign = 32; 524*06f32e7eSjoerg this->IntMaxType = TargetInfo::SignedLongLong; 525*06f32e7eSjoerg this->Int64Type = TargetInfo::SignedLongLong; 526*06f32e7eSjoerg this->SizeType = TargetInfo::UnsignedInt; 527*06f32e7eSjoerg this->resetDataLayout("E-m:e-p:32:32-i64:64-n32:64"); 528*06f32e7eSjoerg } 529*06f32e7eSjoerg }; 530*06f32e7eSjoerg 531*06f32e7eSjoerg template <typename Target> 532*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY PS4OSTargetInfo : public OSTargetInfo<Target> { 533*06f32e7eSjoerg protected: 534*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 535*06f32e7eSjoerg MacroBuilder &Builder) const override { 536*06f32e7eSjoerg Builder.defineMacro("__FreeBSD__", "9"); 537*06f32e7eSjoerg Builder.defineMacro("__FreeBSD_cc_version", "900001"); 538*06f32e7eSjoerg Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 539*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 540*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 541*06f32e7eSjoerg Builder.defineMacro("__ORBIS__"); 542*06f32e7eSjoerg } 543*06f32e7eSjoerg 544*06f32e7eSjoerg public: 545*06f32e7eSjoerg PS4OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 546*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 547*06f32e7eSjoerg this->WCharType = TargetInfo::UnsignedShort; 548*06f32e7eSjoerg 549*06f32e7eSjoerg // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits). 550*06f32e7eSjoerg this->MaxTLSAlign = 256; 551*06f32e7eSjoerg 552*06f32e7eSjoerg // On PS4, do not honor explicit bit field alignment, 553*06f32e7eSjoerg // as in "__attribute__((aligned(2))) int b : 1;". 554*06f32e7eSjoerg this->UseExplicitBitFieldAlignment = false; 555*06f32e7eSjoerg 556*06f32e7eSjoerg switch (Triple.getArch()) { 557*06f32e7eSjoerg default: 558*06f32e7eSjoerg case llvm::Triple::x86_64: 559*06f32e7eSjoerg this->MCountName = ".mcount"; 560*06f32e7eSjoerg this->NewAlign = 256; 561*06f32e7eSjoerg break; 562*06f32e7eSjoerg } 563*06f32e7eSjoerg } 564*06f32e7eSjoerg TargetInfo::CallingConvCheckResult 565*06f32e7eSjoerg checkCallingConvention(CallingConv CC) const override { 566*06f32e7eSjoerg return (CC == CC_C) ? TargetInfo::CCCR_OK : TargetInfo::CCCR_Error; 567*06f32e7eSjoerg } 568*06f32e7eSjoerg }; 569*06f32e7eSjoerg 570*06f32e7eSjoerg // RTEMS Target 571*06f32e7eSjoerg template <typename Target> 572*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> { 573*06f32e7eSjoerg protected: 574*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 575*06f32e7eSjoerg MacroBuilder &Builder) const override { 576*06f32e7eSjoerg // RTEMS defines; list based off of gcc output 577*06f32e7eSjoerg 578*06f32e7eSjoerg Builder.defineMacro("__rtems__"); 579*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 580*06f32e7eSjoerg if (Opts.CPlusPlus) 581*06f32e7eSjoerg Builder.defineMacro("_GNU_SOURCE"); 582*06f32e7eSjoerg } 583*06f32e7eSjoerg 584*06f32e7eSjoerg public: 585*06f32e7eSjoerg RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 586*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 587*06f32e7eSjoerg switch (Triple.getArch()) { 588*06f32e7eSjoerg default: 589*06f32e7eSjoerg case llvm::Triple::x86: 590*06f32e7eSjoerg // this->MCountName = ".mcount"; 591*06f32e7eSjoerg break; 592*06f32e7eSjoerg case llvm::Triple::mips: 593*06f32e7eSjoerg case llvm::Triple::mipsel: 594*06f32e7eSjoerg case llvm::Triple::ppc: 595*06f32e7eSjoerg case llvm::Triple::ppc64: 596*06f32e7eSjoerg case llvm::Triple::ppc64le: 597*06f32e7eSjoerg // this->MCountName = "_mcount"; 598*06f32e7eSjoerg break; 599*06f32e7eSjoerg case llvm::Triple::arm: 600*06f32e7eSjoerg // this->MCountName = "__mcount"; 601*06f32e7eSjoerg break; 602*06f32e7eSjoerg } 603*06f32e7eSjoerg } 604*06f32e7eSjoerg }; 605*06f32e7eSjoerg 606*06f32e7eSjoerg // Solaris target 607*06f32e7eSjoerg template <typename Target> 608*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> { 609*06f32e7eSjoerg protected: 610*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 611*06f32e7eSjoerg MacroBuilder &Builder) const override { 612*06f32e7eSjoerg DefineStd(Builder, "sun", Opts); 613*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 614*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 615*06f32e7eSjoerg Builder.defineMacro("__svr4__"); 616*06f32e7eSjoerg Builder.defineMacro("__SVR4"); 617*06f32e7eSjoerg // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and 618*06f32e7eSjoerg // newer, but to 500 for everything else. feature_test.h has a check to 619*06f32e7eSjoerg // ensure that you are not using C99 with an old version of X/Open or C89 620*06f32e7eSjoerg // with a new version. 621*06f32e7eSjoerg if (Opts.C99) 622*06f32e7eSjoerg Builder.defineMacro("_XOPEN_SOURCE", "600"); 623*06f32e7eSjoerg else 624*06f32e7eSjoerg Builder.defineMacro("_XOPEN_SOURCE", "500"); 625*06f32e7eSjoerg if (Opts.CPlusPlus) { 626*06f32e7eSjoerg Builder.defineMacro("__C99FEATURES__"); 627*06f32e7eSjoerg Builder.defineMacro("_FILE_OFFSET_BITS", "64"); 628*06f32e7eSjoerg } 629*06f32e7eSjoerg // GCC restricts the next two to C++. 630*06f32e7eSjoerg Builder.defineMacro("_LARGEFILE_SOURCE"); 631*06f32e7eSjoerg Builder.defineMacro("_LARGEFILE64_SOURCE"); 632*06f32e7eSjoerg Builder.defineMacro("__EXTENSIONS__"); 633*06f32e7eSjoerg if (Opts.POSIXThreads) 634*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 635*06f32e7eSjoerg if (this->HasFloat128) 636*06f32e7eSjoerg Builder.defineMacro("__FLOAT128__"); 637*06f32e7eSjoerg } 638*06f32e7eSjoerg 639*06f32e7eSjoerg public: 640*06f32e7eSjoerg SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 641*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 642*06f32e7eSjoerg if (this->PointerWidth == 64) { 643*06f32e7eSjoerg this->WCharType = this->WIntType = this->SignedInt; 644*06f32e7eSjoerg } else { 645*06f32e7eSjoerg this->WCharType = this->WIntType = this->SignedLong; 646*06f32e7eSjoerg } 647*06f32e7eSjoerg switch (Triple.getArch()) { 648*06f32e7eSjoerg default: 649*06f32e7eSjoerg break; 650*06f32e7eSjoerg case llvm::Triple::x86: 651*06f32e7eSjoerg case llvm::Triple::x86_64: 652*06f32e7eSjoerg this->HasFloat128 = true; 653*06f32e7eSjoerg break; 654*06f32e7eSjoerg } 655*06f32e7eSjoerg } 656*06f32e7eSjoerg }; 657*06f32e7eSjoerg 658*06f32e7eSjoerg // AIX Target 659*06f32e7eSjoerg template <typename Target> 660*06f32e7eSjoerg class AIXTargetInfo : public OSTargetInfo<Target> { 661*06f32e7eSjoerg protected: 662*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 663*06f32e7eSjoerg MacroBuilder &Builder) const override { 664*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 665*06f32e7eSjoerg Builder.defineMacro("_IBMR2"); 666*06f32e7eSjoerg Builder.defineMacro("_POWER"); 667*06f32e7eSjoerg 668*06f32e7eSjoerg Builder.defineMacro("_AIX"); 669*06f32e7eSjoerg 670*06f32e7eSjoerg unsigned Major, Minor, Micro; 671*06f32e7eSjoerg Triple.getOSVersion(Major, Minor, Micro); 672*06f32e7eSjoerg 673*06f32e7eSjoerg // Define AIX OS-Version Macros. 674*06f32e7eSjoerg // Includes logic for legacy versions of AIX; no specific intent to support. 675*06f32e7eSjoerg std::pair<int, int> OsVersion = {Major, Minor}; 676*06f32e7eSjoerg if (OsVersion >= std::make_pair(3, 2)) Builder.defineMacro("_AIX32"); 677*06f32e7eSjoerg if (OsVersion >= std::make_pair(4, 1)) Builder.defineMacro("_AIX41"); 678*06f32e7eSjoerg if (OsVersion >= std::make_pair(4, 3)) Builder.defineMacro("_AIX43"); 679*06f32e7eSjoerg if (OsVersion >= std::make_pair(5, 0)) Builder.defineMacro("_AIX50"); 680*06f32e7eSjoerg if (OsVersion >= std::make_pair(5, 1)) Builder.defineMacro("_AIX51"); 681*06f32e7eSjoerg if (OsVersion >= std::make_pair(5, 2)) Builder.defineMacro("_AIX52"); 682*06f32e7eSjoerg if (OsVersion >= std::make_pair(5, 3)) Builder.defineMacro("_AIX53"); 683*06f32e7eSjoerg if (OsVersion >= std::make_pair(6, 1)) Builder.defineMacro("_AIX61"); 684*06f32e7eSjoerg if (OsVersion >= std::make_pair(7, 1)) Builder.defineMacro("_AIX71"); 685*06f32e7eSjoerg if (OsVersion >= std::make_pair(7, 2)) Builder.defineMacro("_AIX72"); 686*06f32e7eSjoerg 687*06f32e7eSjoerg // FIXME: Do not define _LONG_LONG when -fno-long-long is specified. 688*06f32e7eSjoerg Builder.defineMacro("_LONG_LONG"); 689*06f32e7eSjoerg 690*06f32e7eSjoerg if (Opts.POSIXThreads) { 691*06f32e7eSjoerg Builder.defineMacro("_THREAD_SAFE"); 692*06f32e7eSjoerg } 693*06f32e7eSjoerg 694*06f32e7eSjoerg if (this->PointerWidth == 64) { 695*06f32e7eSjoerg Builder.defineMacro("__64BIT__"); 696*06f32e7eSjoerg } 697*06f32e7eSjoerg 698*06f32e7eSjoerg // Define _WCHAR_T when it is a fundamental type 699*06f32e7eSjoerg // (i.e., for C++ without -fno-wchar). 700*06f32e7eSjoerg if (Opts.CPlusPlus && Opts.WChar) { 701*06f32e7eSjoerg Builder.defineMacro("_WCHAR_T"); 702*06f32e7eSjoerg } 703*06f32e7eSjoerg } 704*06f32e7eSjoerg 705*06f32e7eSjoerg public: 706*06f32e7eSjoerg AIXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 707*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 708*06f32e7eSjoerg if (this->PointerWidth == 64) { 709*06f32e7eSjoerg this->WCharType = this->UnsignedInt; 710*06f32e7eSjoerg } else { 711*06f32e7eSjoerg this->WCharType = this->UnsignedShort; 712*06f32e7eSjoerg } 713*06f32e7eSjoerg this->UseZeroLengthBitfieldAlignment = true; 714*06f32e7eSjoerg } 715*06f32e7eSjoerg 716*06f32e7eSjoerg // AIX sets FLT_EVAL_METHOD to be 1. 717*06f32e7eSjoerg unsigned getFloatEvalMethod() const override { return 1; } 718*06f32e7eSjoerg bool hasInt128Type() const override { return false; } 719*06f32e7eSjoerg }; 720*06f32e7eSjoerg 721*06f32e7eSjoerg void addWindowsDefines(const llvm::Triple &Triple, const LangOptions &Opts, 722*06f32e7eSjoerg MacroBuilder &Builder); 723*06f32e7eSjoerg 724*06f32e7eSjoerg // Windows target 725*06f32e7eSjoerg template <typename Target> 726*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> { 727*06f32e7eSjoerg protected: 728*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 729*06f32e7eSjoerg MacroBuilder &Builder) const override { 730*06f32e7eSjoerg addWindowsDefines(Triple, Opts, Builder); 731*06f32e7eSjoerg } 732*06f32e7eSjoerg 733*06f32e7eSjoerg public: 734*06f32e7eSjoerg WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 735*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 736*06f32e7eSjoerg this->WCharType = TargetInfo::UnsignedShort; 737*06f32e7eSjoerg this->WIntType = TargetInfo::UnsignedShort; 738*06f32e7eSjoerg } 739*06f32e7eSjoerg }; 740*06f32e7eSjoerg 741*06f32e7eSjoerg template <typename Target> 742*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY NaClTargetInfo : public OSTargetInfo<Target> { 743*06f32e7eSjoerg protected: 744*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 745*06f32e7eSjoerg MacroBuilder &Builder) const override { 746*06f32e7eSjoerg if (Opts.POSIXThreads) 747*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 748*06f32e7eSjoerg if (Opts.CPlusPlus) 749*06f32e7eSjoerg Builder.defineMacro("_GNU_SOURCE"); 750*06f32e7eSjoerg 751*06f32e7eSjoerg DefineStd(Builder, "unix", Opts); 752*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 753*06f32e7eSjoerg Builder.defineMacro("__native_client__"); 754*06f32e7eSjoerg } 755*06f32e7eSjoerg 756*06f32e7eSjoerg public: 757*06f32e7eSjoerg NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 758*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 759*06f32e7eSjoerg this->LongAlign = 32; 760*06f32e7eSjoerg this->LongWidth = 32; 761*06f32e7eSjoerg this->PointerAlign = 32; 762*06f32e7eSjoerg this->PointerWidth = 32; 763*06f32e7eSjoerg this->IntMaxType = TargetInfo::SignedLongLong; 764*06f32e7eSjoerg this->Int64Type = TargetInfo::SignedLongLong; 765*06f32e7eSjoerg this->DoubleAlign = 64; 766*06f32e7eSjoerg this->LongDoubleWidth = 64; 767*06f32e7eSjoerg this->LongDoubleAlign = 64; 768*06f32e7eSjoerg this->LongLongWidth = 64; 769*06f32e7eSjoerg this->LongLongAlign = 64; 770*06f32e7eSjoerg this->SizeType = TargetInfo::UnsignedInt; 771*06f32e7eSjoerg this->PtrDiffType = TargetInfo::SignedInt; 772*06f32e7eSjoerg this->IntPtrType = TargetInfo::SignedInt; 773*06f32e7eSjoerg // RegParmMax is inherited from the underlying architecture. 774*06f32e7eSjoerg this->LongDoubleFormat = &llvm::APFloat::IEEEdouble(); 775*06f32e7eSjoerg if (Triple.getArch() == llvm::Triple::arm) { 776*06f32e7eSjoerg // Handled in ARM's setABI(). 777*06f32e7eSjoerg } else if (Triple.getArch() == llvm::Triple::x86) { 778*06f32e7eSjoerg this->resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-" 779*06f32e7eSjoerg "i64:64-n8:16:32-S128"); 780*06f32e7eSjoerg } else if (Triple.getArch() == llvm::Triple::x86_64) { 781*06f32e7eSjoerg this->resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-" 782*06f32e7eSjoerg "i64:64-n8:16:32:64-S128"); 783*06f32e7eSjoerg } else if (Triple.getArch() == llvm::Triple::mipsel) { 784*06f32e7eSjoerg // Handled on mips' setDataLayout. 785*06f32e7eSjoerg } else { 786*06f32e7eSjoerg assert(Triple.getArch() == llvm::Triple::le32); 787*06f32e7eSjoerg this->resetDataLayout("e-p:32:32-i64:64"); 788*06f32e7eSjoerg } 789*06f32e7eSjoerg } 790*06f32e7eSjoerg }; 791*06f32e7eSjoerg 792*06f32e7eSjoerg // Fuchsia Target 793*06f32e7eSjoerg template <typename Target> 794*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> { 795*06f32e7eSjoerg protected: 796*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 797*06f32e7eSjoerg MacroBuilder &Builder) const override { 798*06f32e7eSjoerg Builder.defineMacro("__Fuchsia__"); 799*06f32e7eSjoerg Builder.defineMacro("__ELF__"); 800*06f32e7eSjoerg if (Opts.POSIXThreads) 801*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 802*06f32e7eSjoerg // Required by the libc++ locale support. 803*06f32e7eSjoerg if (Opts.CPlusPlus) 804*06f32e7eSjoerg Builder.defineMacro("_GNU_SOURCE"); 805*06f32e7eSjoerg } 806*06f32e7eSjoerg 807*06f32e7eSjoerg public: 808*06f32e7eSjoerg FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 809*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 810*06f32e7eSjoerg this->MCountName = "__mcount"; 811*06f32e7eSjoerg } 812*06f32e7eSjoerg }; 813*06f32e7eSjoerg 814*06f32e7eSjoerg // WebAssembly target 815*06f32e7eSjoerg template <typename Target> 816*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo 817*06f32e7eSjoerg : public OSTargetInfo<Target> { 818*06f32e7eSjoerg protected: 819*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 820*06f32e7eSjoerg MacroBuilder &Builder) const { 821*06f32e7eSjoerg // A common platform macro. 822*06f32e7eSjoerg if (Opts.POSIXThreads) 823*06f32e7eSjoerg Builder.defineMacro("_REENTRANT"); 824*06f32e7eSjoerg // Follow g++ convention and predefine _GNU_SOURCE for C++. 825*06f32e7eSjoerg if (Opts.CPlusPlus) 826*06f32e7eSjoerg Builder.defineMacro("_GNU_SOURCE"); 827*06f32e7eSjoerg // Indicate that we have __float128. 828*06f32e7eSjoerg Builder.defineMacro("__FLOAT128__"); 829*06f32e7eSjoerg } 830*06f32e7eSjoerg 831*06f32e7eSjoerg public: 832*06f32e7eSjoerg explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple, 833*06f32e7eSjoerg const TargetOptions &Opts) 834*06f32e7eSjoerg : OSTargetInfo<Target>(Triple, Opts) { 835*06f32e7eSjoerg this->MCountName = "__mcount"; 836*06f32e7eSjoerg this->TheCXXABI.set(TargetCXXABI::WebAssembly); 837*06f32e7eSjoerg this->HasFloat128 = true; 838*06f32e7eSjoerg } 839*06f32e7eSjoerg }; 840*06f32e7eSjoerg 841*06f32e7eSjoerg // WASI target 842*06f32e7eSjoerg template <typename Target> 843*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY WASITargetInfo 844*06f32e7eSjoerg : public WebAssemblyOSTargetInfo<Target> { 845*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 846*06f32e7eSjoerg MacroBuilder &Builder) const final { 847*06f32e7eSjoerg WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder); 848*06f32e7eSjoerg Builder.defineMacro("__wasi__"); 849*06f32e7eSjoerg } 850*06f32e7eSjoerg 851*06f32e7eSjoerg public: 852*06f32e7eSjoerg explicit WASITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 853*06f32e7eSjoerg : WebAssemblyOSTargetInfo<Target>(Triple, Opts) {} 854*06f32e7eSjoerg }; 855*06f32e7eSjoerg 856*06f32e7eSjoerg // Emscripten target 857*06f32e7eSjoerg template <typename Target> 858*06f32e7eSjoerg class LLVM_LIBRARY_VISIBILITY EmscriptenTargetInfo 859*06f32e7eSjoerg : public WebAssemblyOSTargetInfo<Target> { 860*06f32e7eSjoerg void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 861*06f32e7eSjoerg MacroBuilder &Builder) const final { 862*06f32e7eSjoerg WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder); 863*06f32e7eSjoerg Builder.defineMacro("__EMSCRIPTEN__"); 864*06f32e7eSjoerg } 865*06f32e7eSjoerg 866*06f32e7eSjoerg public: 867*06f32e7eSjoerg explicit EmscriptenTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 868*06f32e7eSjoerg : WebAssemblyOSTargetInfo<Target>(Triple, Opts) {} 869*06f32e7eSjoerg }; 870*06f32e7eSjoerg 871*06f32e7eSjoerg } // namespace targets 872*06f32e7eSjoerg } // namespace clang 873*06f32e7eSjoerg #endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H 874