1 //===--- OSTargets.h - Declare OS target feature support --------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file declares OS specific TargetInfo types. 10 //===----------------------------------------------------------------------===// 11 12 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H 13 #define LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H 14 15 #include "Targets.h" 16 17 namespace clang { 18 namespace targets { 19 20 template <typename TgtInfo> 21 class LLVM_LIBRARY_VISIBILITY OSTargetInfo : public TgtInfo { 22 protected: 23 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 24 MacroBuilder &Builder) const = 0; 25 26 public: OSTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)27 OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 28 : TgtInfo(Triple, Opts) {} 29 getTargetDefines(const LangOptions & Opts,MacroBuilder & Builder)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 37 void getAppleMachODefines(MacroBuilder &Builder, const LangOptions &Opts, 38 const llvm::Triple &Triple); 39 40 void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, 41 const llvm::Triple &Triple, StringRef &PlatformName, 42 VersionTuple &PlatformMinVersion); 43 44 template <typename Target> 45 class LLVM_LIBRARY_VISIBILITY AppleMachOTargetInfo 46 : public OSTargetInfo<Target> { 47 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)48 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 49 MacroBuilder &Builder) const override { 50 getAppleMachODefines(Builder, Opts, Triple); 51 } 52 53 public: AppleMachOTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)54 AppleMachOTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 55 : OSTargetInfo<Target>(Triple, Opts) {} 56 getStaticInitSectionSpecifier()57 const char *getStaticInitSectionSpecifier() const override { 58 return "__TEXT,__StaticInit,regular,pure_instructions"; 59 } 60 61 /// Apple Mach-O does not support protected visibility. Its "default" is very 62 /// similar to ELF's "protected"; Apple Mach-O requires a "weak" attribute on 63 /// declarations that can be dynamically replaced. hasProtectedVisibility()64 bool hasProtectedVisibility() const override { return false; } 65 }; 66 67 template <typename Target> 68 class LLVM_LIBRARY_VISIBILITY DarwinTargetInfo 69 : public AppleMachOTargetInfo<Target> { 70 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)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 77 public: DarwinTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)78 DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 79 : AppleMachOTargetInfo<Target>(Triple, Opts) { 80 // By default, no TLS, and we list permitted architecture/OS 81 // 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 else 95 this->TLSSupported = !Triple.isOSVersionLT(10); 96 } 97 } else if (Triple.isWatchOS()) { 98 if (!Triple.isSimulatorEnvironment()) 99 this->TLSSupported = !Triple.isOSVersionLT(2); 100 else 101 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 getStaticInitSectionSpecifier()110 const char *getStaticInitSectionSpecifier() const override { 111 // FIXME: We should return 0 when building kexts. 112 return AppleMachOTargetInfo<Target>::getStaticInitSectionSpecifier(); 113 } 114 getExnObjectAlignment()115 unsigned getExnObjectAlignment() const override { 116 // Older versions of libc++abi guarantee an alignment of only 8-bytes for 117 // exception objects because of a bug in __cxa_exception that was 118 // 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 getLeastIntTypeByWidth(unsigned BitWidth,bool IsSigned)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 == 64 152 ? (IsSigned ? TargetInfo::SignedLongLong 153 : TargetInfo::UnsignedLongLong) 154 : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned); 155 } 156 areDefaultedSMFStillPOD(const LangOptions &)157 bool areDefaultedSMFStillPOD(const LangOptions &) const override { 158 return false; 159 } 160 }; 161 162 // DragonFlyBSD Target 163 template <typename Target> 164 class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo 165 : public OSTargetInfo<Target> { 166 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)167 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 168 MacroBuilder &Builder) const override { 169 // DragonFly defines; list based off of gcc output 170 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 182 public: DragonFlyBSDTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)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_VERSION 197 #define FREEBSD_CC_VERSION 0U 198 #endif 199 200 // FreeBSD Target 201 template <typename Target> 202 class LLVM_LIBRARY_VISIBILITY FreeBSDTargetInfo : public OSTargetInfo<Target> { 203 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)204 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 205 MacroBuilder &Builder) const override { 206 // FreeBSD defines; list based off of gcc output 207 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 as 223 // used by the character set of the locale. These character sets are 224 // not necessarily a superset of ASCII. 225 // 226 // FIXME: This is wrong; the macro refers to the numerical values 227 // of wchar_t *literals*, which are not locale-dependent. However, 228 // FreeBSD systems apparently depend on us getting this wrong, and 229 // setting this to 1 is conforming even if all the basic source 230 // character literals have the same encoding as char and wchar_t. 231 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1"); 232 } 233 234 public: FreeBSDTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)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 Target 264 template <typename Target> 265 class LLVM_LIBRARY_VISIBILITY KFreeBSDTargetInfo : public OSTargetInfo<Target> { 266 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)267 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 268 MacroBuilder &Builder) const override { 269 // GNU/kFreeBSD defines; list based off of gcc output 270 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 280 public: 281 using OSTargetInfo<Target>::OSTargetInfo; 282 }; 283 284 // Haiku Target 285 template <typename Target> 286 class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> { 287 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)288 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 289 MacroBuilder &Builder) const override { 290 // Haiku defines; list based off of gcc output 291 Builder.defineMacro("__HAIKU__"); 292 DefineStd(Builder, "unix", Opts); 293 if (this->HasFloat128) 294 Builder.defineMacro("__FLOAT128__"); 295 } 296 297 public: HaikuTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)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 target 316 template <typename Target> 317 class LLVM_LIBRARY_VISIBILITY HurdTargetInfo : public OSTargetInfo<Target> { 318 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)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 } 332 public: 333 using OSTargetInfo<Target>::OSTargetInfo; 334 }; 335 336 // Linux target 337 template <typename Target> 338 class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> { 339 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)340 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 341 MacroBuilder &Builder) const override { 342 // Linux defines; list based off of gcc output 343 DefineStd(Builder, "unix", Opts); 344 DefineStd(Builder, "linux", Opts); 345 if (Triple.isAndroid()) { 346 Builder.defineMacro("__ANDROID__", "1"); 347 this->PlatformName = "android"; 348 this->PlatformMinVersion = Triple.getEnvironmentVersion(); 349 const unsigned Maj = this->PlatformMinVersion.getMajor(); 350 if (Maj) { 351 Builder.defineMacro("__ANDROID_MIN_SDK_VERSION__", Twine(Maj)); 352 // This historical but ambiguous name for the minSdkVersion macro. Keep 353 // defined for compatibility. 354 Builder.defineMacro("__ANDROID_API__", "__ANDROID_MIN_SDK_VERSION__"); 355 } 356 } else { 357 Builder.defineMacro("__gnu_linux__"); 358 } 359 if (Opts.POSIXThreads) 360 Builder.defineMacro("_REENTRANT"); 361 if (Opts.CPlusPlus) 362 Builder.defineMacro("_GNU_SOURCE"); 363 if (this->HasFloat128) 364 Builder.defineMacro("__FLOAT128__"); 365 if (Triple.isTime64ABI()) { 366 Builder.defineMacro("_FILE_OFFSET_BITS", "64"); 367 Builder.defineMacro("_TIME_BITS", "64"); 368 } 369 } 370 371 public: LinuxTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)372 LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 373 : OSTargetInfo<Target>(Triple, Opts) { 374 this->WIntType = TargetInfo::UnsignedInt; 375 376 switch (Triple.getArch()) { 377 default: 378 break; 379 case llvm::Triple::mips: 380 case llvm::Triple::mipsel: 381 case llvm::Triple::mips64: 382 case llvm::Triple::mips64el: 383 case llvm::Triple::ppc: 384 case llvm::Triple::ppcle: 385 case llvm::Triple::ppc64: 386 case llvm::Triple::ppc64le: 387 this->MCountName = "_mcount"; 388 break; 389 case llvm::Triple::x86: 390 case llvm::Triple::x86_64: 391 this->HasFloat128 = true; 392 break; 393 } 394 } 395 getStaticInitSectionSpecifier()396 const char *getStaticInitSectionSpecifier() const override { 397 return ".text.startup"; 398 } 399 }; 400 401 // Managarm Target 402 template <typename Target> 403 class LLVM_LIBRARY_VISIBILITY ManagarmTargetInfo : public OSTargetInfo<Target> { 404 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)405 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 406 MacroBuilder &Builder) const override { 407 DefineStd(Builder, "unix", Opts); 408 Builder.defineMacro("__managarm__"); 409 if (Opts.POSIXThreads) 410 Builder.defineMacro("_REENTRANT"); 411 if (Opts.CPlusPlus) 412 Builder.defineMacro("_GNU_SOURCE"); 413 if (this->HasFloat128) 414 Builder.defineMacro("__FLOAT128__"); 415 } 416 417 public: ManagarmTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)418 ManagarmTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 419 : OSTargetInfo<Target>(Triple, Opts) { 420 switch (Triple.getArch()) { 421 default: 422 break; 423 case llvm::Triple::x86: 424 case llvm::Triple::x86_64: 425 this->HasFloat128 = true; 426 break; 427 } 428 } 429 }; 430 431 // NetBSD Target 432 template <typename Target> 433 class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> { 434 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)435 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 436 MacroBuilder &Builder) const override { 437 // NetBSD defines; list based off of gcc output 438 Builder.defineMacro("__NetBSD__"); 439 Builder.defineMacro("__unix__"); 440 if (Opts.POSIXThreads) 441 Builder.defineMacro("_REENTRANT"); 442 if (this->HasFloat128) 443 Builder.defineMacro("__FLOAT128__"); 444 } 445 446 public: NetBSDTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)447 NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 448 : OSTargetInfo<Target>(Triple, Opts) { 449 this->MCountName = "__mcount"; 450 switch (Triple.getArch()) { 451 default: 452 break; 453 case llvm::Triple::x86: 454 case llvm::Triple::x86_64: 455 this->HasFloat128 = true; 456 break; 457 } 458 } 459 }; 460 461 // OpenBSD Target 462 template <typename Target> 463 class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> { 464 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)465 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 466 MacroBuilder &Builder) const override { 467 // OpenBSD defines; list based off of gcc output 468 469 Builder.defineMacro("__OpenBSD__"); 470 DefineStd(Builder, "unix", Opts); 471 if (Opts.POSIXThreads) 472 Builder.defineMacro("_REENTRANT"); 473 if (this->HasFloat128) 474 Builder.defineMacro("__FLOAT128__"); 475 476 if (Opts.C11) 477 Builder.defineMacro("__STDC_NO_THREADS__"); 478 } 479 480 public: OpenBSDTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)481 OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 482 : OSTargetInfo<Target>(Triple, Opts) { 483 this->WCharType = this->WIntType = this->SignedInt; 484 this->IntMaxType = TargetInfo::SignedLongLong; 485 this->Int64Type = TargetInfo::SignedLongLong; 486 switch (Triple.getArch()) { 487 case llvm::Triple::x86: 488 case llvm::Triple::x86_64: 489 this->HasFloat128 = true; 490 [[fallthrough]]; 491 default: 492 this->MCountName = "__mcount"; 493 break; 494 case llvm::Triple::mips64: 495 case llvm::Triple::mips64el: 496 case llvm::Triple::ppc: 497 case llvm::Triple::ppc64: 498 case llvm::Triple::ppc64le: 499 case llvm::Triple::sparcv9: 500 this->MCountName = "_mcount"; 501 break; 502 case llvm::Triple::loongarch64: 503 case llvm::Triple::riscv64: 504 break; 505 } 506 } 507 }; 508 509 // PS3 PPU Target 510 template <typename Target> 511 class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> { 512 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)513 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 514 MacroBuilder &Builder) const override { 515 // PS3 PPU defines. 516 Builder.defineMacro("__PPU__"); 517 Builder.defineMacro("__CELLOS_LV2__"); 518 Builder.defineMacro("__LP32__"); 519 Builder.defineMacro("_ARCH_PPC64"); 520 Builder.defineMacro("__powerpc64__"); 521 } 522 523 public: PS3PPUTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)524 PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 525 : OSTargetInfo<Target>(Triple, Opts) { 526 this->LongWidth = this->LongAlign = 32; 527 this->PointerWidth = this->PointerAlign = 32; 528 this->IntMaxType = TargetInfo::SignedLongLong; 529 this->Int64Type = TargetInfo::SignedLongLong; 530 this->SizeType = TargetInfo::UnsignedInt; 531 this->resetDataLayout("E-m:e-p:32:32-Fi64-i64:64-i128:128-n32:64"); 532 } 533 }; 534 535 // Common base class for PS4/PS5 targets. 536 template <typename Target> 537 class LLVM_LIBRARY_VISIBILITY PSOSTargetInfo : public OSTargetInfo<Target> { 538 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)539 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 540 MacroBuilder &Builder) const override { 541 Builder.defineMacro("__FreeBSD__", "9"); 542 Builder.defineMacro("__FreeBSD_cc_version", "900001"); 543 Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 544 DefineStd(Builder, "unix", Opts); 545 Builder.defineMacro("__SCE__"); 546 Builder.defineMacro("__STDC_NO_COMPLEX__"); 547 Builder.defineMacro("__STDC_NO_THREADS__"); 548 } 549 550 public: PSOSTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)551 PSOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 552 : OSTargetInfo<Target>(Triple, Opts) { 553 this->WCharType = TargetInfo::UnsignedShort; 554 555 // On PS4/PS5, TLS variable cannot be aligned to more than 32 bytes (256 556 // bits). 557 this->MaxTLSAlign = 256; 558 559 // On PS4/PS5, do not honor explicit bit field alignment, 560 // as in "__attribute__((aligned(2))) int b : 1;". 561 this->UseExplicitBitFieldAlignment = false; 562 563 this->MCountName = ".mcount"; 564 this->NewAlign = 256; 565 this->SuitableAlign = 256; 566 } 567 568 TargetInfo::CallingConvCheckResult checkCallingConvention(CallingConv CC)569 checkCallingConvention(CallingConv CC) const override { 570 return (CC == CC_C) ? TargetInfo::CCCR_OK : TargetInfo::CCCR_Error; 571 } 572 areDefaultedSMFStillPOD(const LangOptions &)573 bool areDefaultedSMFStillPOD(const LangOptions &) const override { 574 return false; 575 } 576 }; 577 578 // PS4 Target 579 template <typename Target> 580 class LLVM_LIBRARY_VISIBILITY PS4OSTargetInfo : public PSOSTargetInfo<Target> { 581 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)582 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 583 MacroBuilder &Builder) const override { 584 // Start with base class defines. 585 PSOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder); 586 587 Builder.defineMacro("__ORBIS__"); 588 } 589 590 public: 591 using PSOSTargetInfo<Target>::PSOSTargetInfo; 592 }; 593 594 // PS5 Target 595 template <typename Target> 596 class LLVM_LIBRARY_VISIBILITY PS5OSTargetInfo : public PSOSTargetInfo<Target> { 597 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)598 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 599 MacroBuilder &Builder) const override { 600 // Start with base class defines. 601 PSOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder); 602 603 Builder.defineMacro("__PROSPERO__"); 604 } 605 606 public: 607 using PSOSTargetInfo<Target>::PSOSTargetInfo; 608 }; 609 610 // RTEMS Target 611 template <typename Target> 612 class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> { 613 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)614 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 615 MacroBuilder &Builder) const override { 616 // RTEMS defines; list based off of gcc output 617 618 Builder.defineMacro("__rtems__"); 619 if (Opts.CPlusPlus) 620 Builder.defineMacro("_GNU_SOURCE"); 621 } 622 623 public: RTEMSTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)624 RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 625 : OSTargetInfo<Target>(Triple, Opts) { 626 switch (Triple.getArch()) { 627 default: 628 case llvm::Triple::x86: 629 // this->MCountName = ".mcount"; 630 break; 631 case llvm::Triple::mips: 632 case llvm::Triple::mipsel: 633 case llvm::Triple::ppc: 634 case llvm::Triple::ppc64: 635 case llvm::Triple::ppc64le: 636 // this->MCountName = "_mcount"; 637 break; 638 case llvm::Triple::arm: 639 // this->MCountName = "__mcount"; 640 break; 641 } 642 } 643 }; 644 645 // Solaris target 646 template <typename Target> 647 class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> { 648 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)649 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 650 MacroBuilder &Builder) const override { 651 DefineStd(Builder, "sun", Opts); 652 DefineStd(Builder, "unix", Opts); 653 Builder.defineMacro("__svr4__"); 654 Builder.defineMacro("__SVR4"); 655 Builder.defineMacro("_XOPEN_SOURCE", "600"); 656 if (Opts.CPlusPlus) { 657 Builder.defineMacro("__C99FEATURES__"); 658 Builder.defineMacro("_FILE_OFFSET_BITS", "64"); 659 } 660 // GCC restricts the next two to C++. 661 Builder.defineMacro("_LARGEFILE_SOURCE"); 662 Builder.defineMacro("_LARGEFILE64_SOURCE"); 663 Builder.defineMacro("__EXTENSIONS__"); 664 if (Opts.POSIXThreads) 665 Builder.defineMacro("_REENTRANT"); 666 if (this->HasFloat128) 667 Builder.defineMacro("__FLOAT128__"); 668 } 669 670 public: SolarisTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)671 SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 672 : OSTargetInfo<Target>(Triple, Opts) { 673 if (this->PointerWidth == 64) { 674 this->WCharType = this->WIntType = this->SignedInt; 675 } else { 676 this->WCharType = this->WIntType = this->SignedLong; 677 } 678 switch (Triple.getArch()) { 679 default: 680 break; 681 case llvm::Triple::x86: 682 case llvm::Triple::x86_64: 683 this->HasFloat128 = true; 684 break; 685 } 686 } 687 }; 688 689 // AIX Target 690 template <typename Target> 691 class AIXTargetInfo : public OSTargetInfo<Target> { 692 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)693 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 694 MacroBuilder &Builder) const override { 695 DefineStd(Builder, "unix", Opts); 696 Builder.defineMacro("_IBMR2"); 697 Builder.defineMacro("_POWER"); 698 Builder.defineMacro("__THW_BIG_ENDIAN__"); 699 700 Builder.defineMacro("_AIX"); 701 Builder.defineMacro("__TOS_AIX__"); 702 Builder.defineMacro("__HOS_AIX__"); 703 704 if (Opts.C11) { 705 Builder.defineMacro("__STDC_NO_ATOMICS__"); 706 Builder.defineMacro("__STDC_NO_THREADS__"); 707 } 708 709 if (Opts.EnableAIXExtendedAltivecABI) 710 Builder.defineMacro("__EXTABI__"); 711 712 VersionTuple OsVersion = Triple.getOSVersion(); 713 714 // Define AIX OS-Version Macros. 715 // Includes logic for legacy versions of AIX; no specific intent to support. 716 if (OsVersion >= VersionTuple(3, 2)) 717 Builder.defineMacro("_AIX32"); 718 if (OsVersion >= VersionTuple(4, 1)) 719 Builder.defineMacro("_AIX41"); 720 if (OsVersion >= VersionTuple(4, 3)) 721 Builder.defineMacro("_AIX43"); 722 if (OsVersion >= VersionTuple(5, 0)) 723 Builder.defineMacro("_AIX50"); 724 if (OsVersion >= VersionTuple(5, 1)) 725 Builder.defineMacro("_AIX51"); 726 if (OsVersion >= VersionTuple(5, 2)) 727 Builder.defineMacro("_AIX52"); 728 if (OsVersion >= VersionTuple(5, 3)) 729 Builder.defineMacro("_AIX53"); 730 if (OsVersion >= VersionTuple(6, 1)) 731 Builder.defineMacro("_AIX61"); 732 if (OsVersion >= VersionTuple(7, 1)) 733 Builder.defineMacro("_AIX71"); 734 if (OsVersion >= VersionTuple(7, 2)) 735 Builder.defineMacro("_AIX72"); 736 if (OsVersion >= VersionTuple(7, 3)) 737 Builder.defineMacro("_AIX73"); 738 739 // FIXME: Do not define _LONG_LONG when -fno-long-long is specified. 740 Builder.defineMacro("_LONG_LONG"); 741 742 if (Opts.POSIXThreads) { 743 Builder.defineMacro("_THREAD_SAFE"); 744 } 745 746 if (this->PointerWidth == 64) { 747 Builder.defineMacro("__64BIT__"); 748 } 749 750 // Define _WCHAR_T when it is a fundamental type 751 // (i.e., for C++ without -fno-wchar). 752 if (Opts.CPlusPlus && Opts.WChar) { 753 Builder.defineMacro("_WCHAR_T"); 754 } 755 } 756 757 public: AIXTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)758 AIXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 759 : OSTargetInfo<Target>(Triple, Opts) { 760 this->MCountName = "__mcount"; 761 this->TheCXXABI.set(TargetCXXABI::XL); 762 763 if (this->PointerWidth == 64) { 764 this->WCharType = this->UnsignedInt; 765 } else { 766 this->WCharType = this->UnsignedShort; 767 } 768 this->UseZeroLengthBitfieldAlignment = true; 769 } 770 771 // AIX sets FLT_EVAL_METHOD to be 1. getFPEvalMethod()772 LangOptions::FPEvalMethodKind getFPEvalMethod() const override { 773 return LangOptions::FPEvalMethodKind::FEM_Double; 774 } 775 defaultsToAIXPowerAlignment()776 bool defaultsToAIXPowerAlignment() const override { return true; } 777 areDefaultedSMFStillPOD(const LangOptions &)778 bool areDefaultedSMFStillPOD(const LangOptions &) const override { 779 return false; 780 } 781 }; 782 783 // z/OS target 784 template <typename Target> 785 class LLVM_LIBRARY_VISIBILITY ZOSTargetInfo : public OSTargetInfo<Target> { 786 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)787 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 788 MacroBuilder &Builder) const override { 789 // FIXME: _LONG_LONG should not be defined under -std=c89. 790 Builder.defineMacro("_LONG_LONG"); 791 Builder.defineMacro("__370__"); 792 Builder.defineMacro("__BFP__"); 793 // FIXME: __BOOL__ should not be defined under -std=c89. 794 Builder.defineMacro("__BOOL__"); 795 Builder.defineMacro("__COMPILER_VER__", "0x50000000"); 796 Builder.defineMacro("__LONGNAME__"); 797 Builder.defineMacro("__MVS__"); 798 Builder.defineMacro("__THW_370__"); 799 Builder.defineMacro("__THW_BIG_ENDIAN__"); 800 Builder.defineMacro("__TOS_390__"); 801 Builder.defineMacro("__TOS_MVS__"); 802 Builder.defineMacro("__XPLINK__"); 803 804 if (this->PointerWidth == 64) 805 Builder.defineMacro("__64BIT__"); 806 807 if (Opts.CPlusPlus && Opts.WChar) { 808 // Macro __wchar_t is defined so that the wchar_t data 809 // type is not declared as a typedef in system headers. 810 Builder.defineMacro("__wchar_t"); 811 } 812 813 this->PlatformName = llvm::Triple::getOSTypeName(Triple.getOS()); 814 } 815 816 public: ZOSTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)817 ZOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 818 : OSTargetInfo<Target>(Triple, Opts) { 819 this->WCharType = TargetInfo::UnsignedInt; 820 this->MaxAlignedAttribute = 128; 821 this->UseBitFieldTypeAlignment = false; 822 this->UseZeroLengthBitfieldAlignment = true; 823 this->UseLeadingZeroLengthBitfield = false; 824 this->ZeroLengthBitfieldBoundary = 32; 825 this->TheCXXABI.set(TargetCXXABI::XL); 826 } 827 areDefaultedSMFStillPOD(const LangOptions &)828 bool areDefaultedSMFStillPOD(const LangOptions &) const override { 829 return false; 830 } 831 }; 832 833 // UEFI target 834 template <typename Target> 835 class LLVM_LIBRARY_VISIBILITY UEFITargetInfo : public OSTargetInfo<Target> { 836 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)837 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 838 MacroBuilder &Builder) const override { 839 Builder.defineMacro("__UEFI__"); 840 } 841 842 public: UEFITargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)843 UEFITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 844 : OSTargetInfo<Target>(Triple, Opts) { 845 this->WCharType = TargetInfo::UnsignedShort; 846 this->WIntType = TargetInfo::UnsignedShort; 847 this->UseMicrosoftManglingForC = true; 848 } 849 }; 850 851 void addWindowsDefines(const llvm::Triple &Triple, const LangOptions &Opts, 852 MacroBuilder &Builder); 853 854 // Windows target 855 template <typename Target> 856 class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> { 857 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)858 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 859 MacroBuilder &Builder) const override { 860 addWindowsDefines(Triple, Opts, Builder); 861 } 862 863 public: WindowsTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)864 WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 865 : OSTargetInfo<Target>(Triple, Opts) { 866 this->WCharType = TargetInfo::UnsignedShort; 867 this->WIntType = TargetInfo::UnsignedShort; 868 this->UseMicrosoftManglingForC = true; 869 } 870 }; 871 872 template <typename Target> 873 class LLVM_LIBRARY_VISIBILITY NaClTargetInfo : public OSTargetInfo<Target> { 874 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)875 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 876 MacroBuilder &Builder) const override { 877 if (Opts.POSIXThreads) 878 Builder.defineMacro("_REENTRANT"); 879 if (Opts.CPlusPlus) 880 Builder.defineMacro("_GNU_SOURCE"); 881 882 DefineStd(Builder, "unix", Opts); 883 Builder.defineMacro("__native_client__"); 884 } 885 886 public: NaClTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)887 NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 888 : OSTargetInfo<Target>(Triple, Opts) { 889 this->LongAlign = 32; 890 this->LongWidth = 32; 891 this->PointerAlign = 32; 892 this->PointerWidth = 32; 893 this->IntMaxType = TargetInfo::SignedLongLong; 894 this->Int64Type = TargetInfo::SignedLongLong; 895 this->DoubleAlign = 64; 896 this->LongDoubleWidth = 64; 897 this->LongDoubleAlign = 64; 898 this->LongLongWidth = 64; 899 this->LongLongAlign = 64; 900 this->SizeType = TargetInfo::UnsignedInt; 901 this->PtrDiffType = TargetInfo::SignedInt; 902 this->IntPtrType = TargetInfo::SignedInt; 903 // RegParmMax is inherited from the underlying architecture. 904 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble(); 905 if (Triple.getArch() == llvm::Triple::arm) { 906 // Handled in ARM's setABI(). 907 } else if (Triple.getArch() == llvm::Triple::x86) { 908 this->resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-" 909 "i64:64-i128:128-n8:16:32-S128"); 910 } else if (Triple.getArch() == llvm::Triple::x86_64) { 911 this->resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-" 912 "i64:64-i128:128-n8:16:32:64-S128"); 913 } else if (Triple.getArch() == llvm::Triple::mipsel) { 914 // Handled on mips' setDataLayout. 915 } 916 } 917 }; 918 919 // Fuchsia Target 920 template <typename Target> 921 class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> { 922 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)923 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 924 MacroBuilder &Builder) const override { 925 Builder.defineMacro("__Fuchsia__"); 926 if (Opts.POSIXThreads) 927 Builder.defineMacro("_REENTRANT"); 928 // Required by the libc++ locale support. 929 if (Opts.CPlusPlus) 930 Builder.defineMacro("_GNU_SOURCE"); 931 Builder.defineMacro("__Fuchsia_API_level__", Twine(Opts.FuchsiaAPILevel)); 932 this->PlatformName = "fuchsia"; 933 this->PlatformMinVersion = VersionTuple(Opts.FuchsiaAPILevel); 934 } 935 936 public: FuchsiaTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)937 FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 938 : OSTargetInfo<Target>(Triple, Opts) { 939 this->WIntType = TargetInfo::UnsignedInt; 940 this->MCountName = "__mcount"; 941 this->TheCXXABI.set(TargetCXXABI::Fuchsia); 942 } 943 }; 944 945 // WebAssembly target 946 template <typename Target> 947 class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo 948 : public OSTargetInfo<Target> { 949 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)950 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 951 MacroBuilder &Builder) const override { 952 // A common platform macro. 953 if (Opts.POSIXThreads) 954 Builder.defineMacro("_REENTRANT"); 955 // Follow g++ convention and predefine _GNU_SOURCE for C++. 956 if (Opts.CPlusPlus) 957 Builder.defineMacro("_GNU_SOURCE"); 958 // Indicate that we have __float128. 959 Builder.defineMacro("__FLOAT128__"); 960 } 961 962 public: WebAssemblyOSTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)963 explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple, 964 const TargetOptions &Opts) 965 : OSTargetInfo<Target>(Triple, Opts) { 966 this->MCountName = "__mcount"; 967 this->TheCXXABI.set(TargetCXXABI::WebAssembly); 968 this->HasFloat128 = true; 969 } 970 }; 971 972 // WASI target 973 template <typename Target> 974 class LLVM_LIBRARY_VISIBILITY WASITargetInfo 975 : public WebAssemblyOSTargetInfo<Target> { getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)976 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 977 MacroBuilder &Builder) const final { 978 WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder); 979 Builder.defineMacro("__wasi__"); 980 } 981 982 public: 983 using WebAssemblyOSTargetInfo<Target>::WebAssemblyOSTargetInfo; 984 }; 985 986 // Emscripten target 987 template <typename Target> 988 class LLVM_LIBRARY_VISIBILITY EmscriptenTargetInfo 989 : public WebAssemblyOSTargetInfo<Target> { getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)990 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 991 MacroBuilder &Builder) const final { 992 WebAssemblyOSTargetInfo<Target>::getOSDefines(Opts, Triple, Builder); 993 DefineStd(Builder, "unix", Opts); 994 Builder.defineMacro("__EMSCRIPTEN__"); 995 if (Opts.POSIXThreads) 996 Builder.defineMacro("__EMSCRIPTEN_PTHREADS__"); 997 } 998 999 public: EmscriptenTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)1000 explicit EmscriptenTargetInfo(const llvm::Triple &Triple, 1001 const TargetOptions &Opts) 1002 : WebAssemblyOSTargetInfo<Target>(Triple, Opts) { 1003 // Keeping the alignment of long double to 8 bytes even though its size is 1004 // 16 bytes allows emscripten to have an 8-byte-aligned max_align_t which 1005 // in turn gives is a 8-byte aligned malloc. 1006 // Emscripten's ABI is unstable and we may change this back to 128 to match 1007 // the WebAssembly default in the future. 1008 this->LongDoubleAlign = 64; 1009 this->Float128Align = 64; 1010 } 1011 }; 1012 1013 // OHOS target 1014 template <typename Target> 1015 class LLVM_LIBRARY_VISIBILITY OHOSTargetInfo : public OSTargetInfo<Target> { 1016 protected: getOSDefines(const LangOptions & Opts,const llvm::Triple & Triple,MacroBuilder & Builder)1017 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 1018 MacroBuilder &Builder) const override { 1019 // Linux defines; list based off of gcc output 1020 DefineStd(Builder, "unix", Opts); 1021 1022 // Generic OHOS target defines 1023 if (Triple.isOHOSFamily()) { 1024 Builder.defineMacro("__OHOS_FAMILY__", "1"); 1025 1026 auto Version = Triple.getEnvironmentVersion(); 1027 this->PlatformName = "ohos"; 1028 this->PlatformMinVersion = Version; 1029 Builder.defineMacro("__OHOS_Major__", Twine(Version.getMajor())); 1030 if (auto Minor = Version.getMinor()) 1031 Builder.defineMacro("__OHOS_Minor__", Twine(*Minor)); 1032 if (auto Subminor = Version.getSubminor()) 1033 Builder.defineMacro("__OHOS_Micro__", Twine(*Subminor)); 1034 } 1035 1036 if (Triple.isOpenHOS()) 1037 Builder.defineMacro("__OHOS__"); 1038 1039 if (Triple.isOSLinux()) { 1040 DefineStd(Builder, "linux", Opts); 1041 } else if (Triple.isOSLiteOS()) { 1042 Builder.defineMacro("__LITEOS__"); 1043 } 1044 1045 if (Opts.POSIXThreads) 1046 Builder.defineMacro("_REENTRANT"); 1047 if (Opts.CPlusPlus) 1048 Builder.defineMacro("_GNU_SOURCE"); 1049 if (this->HasFloat128) 1050 Builder.defineMacro("__FLOAT128__"); 1051 } 1052 1053 public: OHOSTargetInfo(const llvm::Triple & Triple,const TargetOptions & Opts)1054 OHOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) 1055 : OSTargetInfo<Target>(Triple, Opts) { 1056 this->WIntType = TargetInfo::UnsignedInt; 1057 1058 switch (Triple.getArch()) { 1059 default: 1060 break; 1061 case llvm::Triple::x86: 1062 case llvm::Triple::x86_64: 1063 this->HasFloat128 = true; 1064 break; 1065 } 1066 } 1067 getStaticInitSectionSpecifier()1068 const char *getStaticInitSectionSpecifier() const override { 1069 return ".text.startup"; 1070 } 1071 }; 1072 1073 } // namespace targets 1074 } // namespace clang 1075 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H 1076