1 //===-- llvm/ADT/Triple.h - Target triple helper class ----------*- 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 #ifndef LLVM_ADT_TRIPLE_H 10 #define LLVM_ADT_TRIPLE_H 11 12 #include "llvm/ADT/Twine.h" 13 14 // Some system headers or GCC predefined macros conflict with identifiers in 15 // this file. Undefine them here. 16 #undef NetBSD 17 #undef mips 18 #undef sparc 19 20 namespace llvm { 21 22 class VersionTuple; 23 24 /// Triple - Helper class for working with autoconf configuration names. For 25 /// historical reasons, we also call these 'triples' (they used to contain 26 /// exactly three fields). 27 /// 28 /// Configuration names are strings in the canonical form: 29 /// ARCHITECTURE-VENDOR-OPERATING_SYSTEM 30 /// or 31 /// ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT 32 /// 33 /// This class is used for clients which want to support arbitrary 34 /// configuration names, but also want to implement certain special 35 /// behavior for particular configurations. This class isolates the mapping 36 /// from the components of the configuration name to well known IDs. 37 /// 38 /// At its core the Triple class is designed to be a wrapper for a triple 39 /// string; the constructor does not change or normalize the triple string. 40 /// Clients that need to handle the non-canonical triples that users often 41 /// specify should use the normalize method. 42 /// 43 /// See autoconf/config.guess for a glimpse into what configuration names 44 /// look like in practice. 45 class Triple { 46 public: 47 enum ArchType { 48 UnknownArch, 49 50 arm, // ARM (little endian): arm, armv.*, xscale 51 armeb, // ARM (big endian): armeb 52 aarch64, // AArch64 (little endian): aarch64 53 aarch64_be, // AArch64 (big endian): aarch64_be 54 aarch64_32, // AArch64 (little endian) ILP32: aarch64_32 55 arc, // ARC: Synopsys ARC 56 avr, // AVR: Atmel AVR microcontroller 57 bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) 58 bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian) 59 csky, // CSKY: csky 60 hexagon, // Hexagon: hexagon 61 m68k, // M68k: Motorola 680x0 family 62 mips, // MIPS: mips, mipsallegrex, mipsr6 63 mipsel, // MIPSEL: mipsel, mipsallegrexe, mipsr6el 64 mips64, // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6 65 mips64el, // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el 66 msp430, // MSP430: msp430 67 ppc, // PPC: powerpc 68 ppcle, // PPCLE: powerpc (little endian) 69 ppc64, // PPC64: powerpc64, ppu 70 ppc64le, // PPC64LE: powerpc64le 71 r600, // R600: AMD GPUs HD2XXX - HD6XXX 72 amdgcn, // AMDGCN: AMD GCN GPUs 73 riscv32, // RISC-V (32-bit): riscv32 74 riscv64, // RISC-V (64-bit): riscv64 75 sparc, // Sparc: sparc 76 sparcv9, // Sparcv9: Sparcv9 77 sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant 78 systemz, // SystemZ: s390x 79 tce, // TCE (http://tce.cs.tut.fi/): tce 80 tcele, // TCE little endian (http://tce.cs.tut.fi/): tcele 81 thumb, // Thumb (little endian): thumb, thumbv.* 82 thumbeb, // Thumb (big endian): thumbeb 83 x86, // X86: i[3-9]86 84 x86_64, // X86-64: amd64, x86_64 85 xcore, // XCore: xcore 86 nvptx, // NVPTX: 32-bit 87 nvptx64, // NVPTX: 64-bit 88 le32, // le32: generic little-endian 32-bit CPU (PNaCl) 89 le64, // le64: generic little-endian 64-bit CPU (PNaCl) 90 amdil, // AMDIL 91 amdil64, // AMDIL with 64-bit pointers 92 hsail, // AMD HSAIL 93 hsail64, // AMD HSAIL with 64-bit pointers 94 spir, // SPIR: standard portable IR for OpenCL 32-bit version 95 spir64, // SPIR: standard portable IR for OpenCL 64-bit version 96 kalimba, // Kalimba: generic kalimba 97 shave, // SHAVE: Movidius vector VLIW processors 98 lanai, // Lanai: Lanai 32-bit 99 wasm32, // WebAssembly with 32-bit pointers 100 wasm64, // WebAssembly with 64-bit pointers 101 renderscript32, // 32-bit RenderScript 102 renderscript64, // 64-bit RenderScript 103 ve, // NEC SX-Aurora Vector Engine 104 LastArchType = ve 105 }; 106 enum SubArchType { 107 NoSubArch, 108 109 ARMSubArch_v8_7a, 110 ARMSubArch_v8_6a, 111 ARMSubArch_v8_5a, 112 ARMSubArch_v8_4a, 113 ARMSubArch_v8_3a, 114 ARMSubArch_v8_2a, 115 ARMSubArch_v8_1a, 116 ARMSubArch_v8, 117 ARMSubArch_v8r, 118 ARMSubArch_v8m_baseline, 119 ARMSubArch_v8m_mainline, 120 ARMSubArch_v8_1m_mainline, 121 ARMSubArch_v7, 122 ARMSubArch_v7em, 123 ARMSubArch_v7m, 124 ARMSubArch_v7s, 125 ARMSubArch_v7k, 126 ARMSubArch_v7ve, 127 ARMSubArch_v6, 128 ARMSubArch_v6m, 129 ARMSubArch_v6k, 130 ARMSubArch_v6t2, 131 ARMSubArch_v5, 132 ARMSubArch_v5te, 133 ARMSubArch_v4t, 134 135 AArch64SubArch_arm64e, 136 137 KalimbaSubArch_v3, 138 KalimbaSubArch_v4, 139 KalimbaSubArch_v5, 140 141 MipsSubArch_r6, 142 143 PPCSubArch_spe 144 }; 145 enum VendorType { 146 UnknownVendor, 147 148 Apple, 149 PC, 150 SCEI, 151 Freescale, 152 IBM, 153 ImaginationTechnologies, 154 MipsTechnologies, 155 NVIDIA, 156 CSR, 157 Myriad, 158 AMD, 159 Mesa, 160 SUSE, 161 OpenEmbedded, 162 LastVendorType = OpenEmbedded 163 }; 164 enum OSType { 165 UnknownOS, 166 167 Ananas, 168 CloudABI, 169 Darwin, 170 DragonFly, 171 FreeBSD, 172 Fuchsia, 173 IOS, 174 KFreeBSD, 175 Linux, 176 Lv2, // PS3 177 MacOSX, 178 NetBSD, 179 OpenBSD, 180 Solaris, 181 Win32, 182 ZOS, 183 Haiku, 184 Minix, 185 RTEMS, 186 NaCl, // Native Client 187 AIX, 188 CUDA, // NVIDIA CUDA 189 NVCL, // NVIDIA OpenCL 190 AMDHSA, // AMD HSA Runtime 191 PS4, 192 ELFIAMCU, 193 TvOS, // Apple tvOS 194 WatchOS, // Apple watchOS 195 Mesa3D, 196 Contiki, 197 AMDPAL, // AMD PAL Runtime 198 HermitCore, // HermitCore Unikernel/Multikernel 199 Hurd, // GNU/Hurd 200 WASI, // Experimental WebAssembly OS 201 Emscripten, 202 LastOSType = Emscripten 203 }; 204 enum EnvironmentType { 205 UnknownEnvironment, 206 207 GNU, 208 GNUABIN32, 209 GNUABI64, 210 GNUEABI, 211 GNUEABIHF, 212 GNUX32, 213 GNUILP32, 214 CODE16, 215 EABI, 216 EABIHF, 217 Android, 218 Musl, 219 MuslEABI, 220 MuslEABIHF, 221 MuslX32, 222 223 MSVC, 224 Itanium, 225 Cygnus, 226 CoreCLR, 227 Simulator, // Simulator variants of other systems, e.g., Apple's iOS 228 MacABI, // Mac Catalyst variant of Apple's iOS deployment target. 229 LastEnvironmentType = MacABI 230 }; 231 enum ObjectFormatType { 232 UnknownObjectFormat, 233 234 COFF, 235 ELF, 236 GOFF, 237 MachO, 238 Wasm, 239 XCOFF, 240 }; 241 242 private: 243 std::string Data; 244 245 /// The parsed arch type. 246 ArchType Arch; 247 248 /// The parsed subarchitecture type. 249 SubArchType SubArch; 250 251 /// The parsed vendor type. 252 VendorType Vendor; 253 254 /// The parsed OS type. 255 OSType OS; 256 257 /// The parsed Environment type. 258 EnvironmentType Environment; 259 260 /// The object format type. 261 ObjectFormatType ObjectFormat; 262 263 public: 264 /// @name Constructors 265 /// @{ 266 267 /// Default constructor is the same as an empty string and leaves all 268 /// triple fields unknown. Triple()269 Triple() 270 : Data(), Arch(), SubArch(), Vendor(), OS(), Environment(), 271 ObjectFormat() {} 272 273 explicit Triple(const Twine &Str); 274 Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr); 275 Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr, 276 const Twine &EnvironmentStr); 277 278 bool operator==(const Triple &Other) const { 279 return Arch == Other.Arch && SubArch == Other.SubArch && 280 Vendor == Other.Vendor && OS == Other.OS && 281 Environment == Other.Environment && 282 ObjectFormat == Other.ObjectFormat; 283 } 284 285 bool operator!=(const Triple &Other) const { 286 return !(*this == Other); 287 } 288 289 /// @} 290 /// @name Normalization 291 /// @{ 292 293 /// normalize - Turn an arbitrary machine specification into the canonical 294 /// triple form (or something sensible that the Triple class understands if 295 /// nothing better can reasonably be done). In particular, it handles the 296 /// common case in which otherwise valid components are in the wrong order. 297 static std::string normalize(StringRef Str); 298 299 /// Return the normalized form of this triple's string. normalize()300 std::string normalize() const { return normalize(Data); } 301 302 /// @} 303 /// @name Typed Component Access 304 /// @{ 305 306 /// getArch - Get the parsed architecture type of this triple. getArch()307 ArchType getArch() const { return Arch; } 308 309 /// getSubArch - get the parsed subarchitecture type for this triple. getSubArch()310 SubArchType getSubArch() const { return SubArch; } 311 312 /// getVendor - Get the parsed vendor type of this triple. getVendor()313 VendorType getVendor() const { return Vendor; } 314 315 /// getOS - Get the parsed operating system type of this triple. getOS()316 OSType getOS() const { return OS; } 317 318 /// hasEnvironment - Does this triple have the optional environment 319 /// (fourth) component? hasEnvironment()320 bool hasEnvironment() const { 321 return getEnvironmentName() != ""; 322 } 323 324 /// getEnvironment - Get the parsed environment type of this triple. getEnvironment()325 EnvironmentType getEnvironment() const { return Environment; } 326 327 /// Parse the version number from the OS name component of the 328 /// triple, if present. 329 /// 330 /// For example, "fooos1.2.3" would return (1, 2, 3). 331 /// 332 /// If an entry is not defined, it will be returned as 0. 333 void getEnvironmentVersion(unsigned &Major, unsigned &Minor, 334 unsigned &Micro) const; 335 336 /// getFormat - Get the object format for this triple. getObjectFormat()337 ObjectFormatType getObjectFormat() const { return ObjectFormat; } 338 339 /// getOSVersion - Parse the version number from the OS name component of the 340 /// triple, if present. 341 /// 342 /// For example, "fooos1.2.3" would return (1, 2, 3). 343 /// 344 /// If an entry is not defined, it will be returned as 0. 345 void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const; 346 347 /// getOSMajorVersion - Return just the major version number, this is 348 /// specialized because it is a common query. getOSMajorVersion()349 unsigned getOSMajorVersion() const { 350 unsigned Maj, Min, Micro; 351 getOSVersion(Maj, Min, Micro); 352 return Maj; 353 } 354 355 /// getMacOSXVersion - Parse the version number as with getOSVersion and then 356 /// translate generic "darwin" versions to the corresponding OS X versions. 357 /// This may also be called with IOS triples but the OS X version number is 358 /// just set to a constant 10.4.0 in that case. Returns true if successful. 359 bool getMacOSXVersion(unsigned &Major, unsigned &Minor, 360 unsigned &Micro) const; 361 362 /// getiOSVersion - Parse the version number as with getOSVersion. This should 363 /// only be called with IOS or generic triples. 364 void getiOSVersion(unsigned &Major, unsigned &Minor, 365 unsigned &Micro) const; 366 367 /// getWatchOSVersion - Parse the version number as with getOSVersion. This 368 /// should only be called with WatchOS or generic triples. 369 void getWatchOSVersion(unsigned &Major, unsigned &Minor, 370 unsigned &Micro) const; 371 372 /// @} 373 /// @name Direct Component Access 374 /// @{ 375 str()376 const std::string &str() const { return Data; } 377 getTriple()378 const std::string &getTriple() const { return Data; } 379 380 /// getArchName - Get the architecture (first) component of the 381 /// triple. 382 StringRef getArchName() const; 383 384 /// getVendorName - Get the vendor (second) component of the triple. 385 StringRef getVendorName() const; 386 387 /// getOSName - Get the operating system (third) component of the 388 /// triple. 389 StringRef getOSName() const; 390 391 /// getEnvironmentName - Get the optional environment (fourth) 392 /// component of the triple, or "" if empty. 393 StringRef getEnvironmentName() const; 394 395 /// getOSAndEnvironmentName - Get the operating system and optional 396 /// environment components as a single string (separated by a '-' 397 /// if the environment component is present). 398 StringRef getOSAndEnvironmentName() const; 399 400 /// @} 401 /// @name Convenience Predicates 402 /// @{ 403 404 /// Test whether the architecture is 64-bit 405 /// 406 /// Note that this tests for 64-bit pointer width, and nothing else. Note 407 /// that we intentionally expose only three predicates, 64-bit, 32-bit, and 408 /// 16-bit. The inner details of pointer width for particular architectures 409 /// is not summed up in the triple, and so only a coarse grained predicate 410 /// system is provided. 411 bool isArch64Bit() const; 412 413 /// Test whether the architecture is 32-bit 414 /// 415 /// Note that this tests for 32-bit pointer width, and nothing else. 416 bool isArch32Bit() const; 417 418 /// Test whether the architecture is 16-bit 419 /// 420 /// Note that this tests for 16-bit pointer width, and nothing else. 421 bool isArch16Bit() const; 422 423 /// isOSVersionLT - Helper function for doing comparisons against version 424 /// numbers included in the target triple. 425 bool isOSVersionLT(unsigned Major, unsigned Minor = 0, 426 unsigned Micro = 0) const { 427 unsigned LHS[3]; 428 getOSVersion(LHS[0], LHS[1], LHS[2]); 429 430 if (LHS[0] != Major) 431 return LHS[0] < Major; 432 if (LHS[1] != Minor) 433 return LHS[1] < Minor; 434 if (LHS[2] != Micro) 435 return LHS[2] < Micro; 436 437 return false; 438 } 439 isOSVersionLT(const Triple & Other)440 bool isOSVersionLT(const Triple &Other) const { 441 unsigned RHS[3]; 442 Other.getOSVersion(RHS[0], RHS[1], RHS[2]); 443 return isOSVersionLT(RHS[0], RHS[1], RHS[2]); 444 } 445 446 /// isMacOSXVersionLT - Comparison function for checking OS X version 447 /// compatibility, which handles supporting skewed version numbering schemes 448 /// used by the "darwin" triples. 449 bool isMacOSXVersionLT(unsigned Major, unsigned Minor = 0, 450 unsigned Micro = 0) const; 451 452 /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both 453 /// "darwin" and "osx" as OS X triples. isMacOSX()454 bool isMacOSX() const { 455 return getOS() == Triple::Darwin || getOS() == Triple::MacOSX; 456 } 457 458 /// Is this an iOS triple. 459 /// Note: This identifies tvOS as a variant of iOS. If that ever 460 /// changes, i.e., if the two operating systems diverge or their version 461 /// numbers get out of sync, that will need to be changed. 462 /// watchOS has completely different version numbers so it is not included. isiOS()463 bool isiOS() const { 464 return getOS() == Triple::IOS || isTvOS(); 465 } 466 467 /// Is this an Apple tvOS triple. isTvOS()468 bool isTvOS() const { 469 return getOS() == Triple::TvOS; 470 } 471 472 /// Is this an Apple watchOS triple. isWatchOS()473 bool isWatchOS() const { 474 return getOS() == Triple::WatchOS; 475 } 476 isWatchABI()477 bool isWatchABI() const { 478 return getSubArch() == Triple::ARMSubArch_v7k; 479 } 480 isOSzOS()481 bool isOSzOS() const { return getOS() == Triple::ZOS; } 482 483 /// isOSDarwin - Is this a "Darwin" OS (macOS, iOS, tvOS or watchOS). isOSDarwin()484 bool isOSDarwin() const { 485 return isMacOSX() || isiOS() || isWatchOS(); 486 } 487 isSimulatorEnvironment()488 bool isSimulatorEnvironment() const { 489 return getEnvironment() == Triple::Simulator; 490 } 491 isMacCatalystEnvironment()492 bool isMacCatalystEnvironment() const { 493 return getEnvironment() == Triple::MacABI; 494 } 495 496 /// Returns true for targets that run on a macOS machine. isTargetMachineMac()497 bool isTargetMachineMac() const { 498 return isMacOSX() || (isOSDarwin() && (isSimulatorEnvironment() || 499 isMacCatalystEnvironment())); 500 } 501 isOSNetBSD()502 bool isOSNetBSD() const { 503 return getOS() == Triple::NetBSD; 504 } 505 isOSOpenBSD()506 bool isOSOpenBSD() const { 507 return getOS() == Triple::OpenBSD; 508 } 509 isOSFreeBSD()510 bool isOSFreeBSD() const { 511 return getOS() == Triple::FreeBSD; 512 } 513 isOSFuchsia()514 bool isOSFuchsia() const { 515 return getOS() == Triple::Fuchsia; 516 } 517 isOSDragonFly()518 bool isOSDragonFly() const { return getOS() == Triple::DragonFly; } 519 isOSSolaris()520 bool isOSSolaris() const { 521 return getOS() == Triple::Solaris; 522 } 523 isOSIAMCU()524 bool isOSIAMCU() const { 525 return getOS() == Triple::ELFIAMCU; 526 } 527 isOSUnknown()528 bool isOSUnknown() const { return getOS() == Triple::UnknownOS; } 529 isGNUEnvironment()530 bool isGNUEnvironment() const { 531 EnvironmentType Env = getEnvironment(); 532 return Env == Triple::GNU || Env == Triple::GNUABIN32 || 533 Env == Triple::GNUABI64 || Env == Triple::GNUEABI || 534 Env == Triple::GNUEABIHF || Env == Triple::GNUX32; 535 } 536 isOSContiki()537 bool isOSContiki() const { 538 return getOS() == Triple::Contiki; 539 } 540 541 /// Tests whether the OS is Haiku. isOSHaiku()542 bool isOSHaiku() const { 543 return getOS() == Triple::Haiku; 544 } 545 546 /// Tests whether the OS is Windows. isOSWindows()547 bool isOSWindows() const { 548 return getOS() == Triple::Win32; 549 } 550 551 /// Checks if the environment is MSVC. isKnownWindowsMSVCEnvironment()552 bool isKnownWindowsMSVCEnvironment() const { 553 return isOSWindows() && getEnvironment() == Triple::MSVC; 554 } 555 556 /// Checks if the environment could be MSVC. isWindowsMSVCEnvironment()557 bool isWindowsMSVCEnvironment() const { 558 return isKnownWindowsMSVCEnvironment() || 559 (isOSWindows() && getEnvironment() == Triple::UnknownEnvironment); 560 } 561 isWindowsCoreCLREnvironment()562 bool isWindowsCoreCLREnvironment() const { 563 return isOSWindows() && getEnvironment() == Triple::CoreCLR; 564 } 565 isWindowsItaniumEnvironment()566 bool isWindowsItaniumEnvironment() const { 567 return isOSWindows() && getEnvironment() == Triple::Itanium; 568 } 569 isWindowsCygwinEnvironment()570 bool isWindowsCygwinEnvironment() const { 571 return isOSWindows() && getEnvironment() == Triple::Cygnus; 572 } 573 isWindowsGNUEnvironment()574 bool isWindowsGNUEnvironment() const { 575 return isOSWindows() && getEnvironment() == Triple::GNU; 576 } 577 578 /// Tests for either Cygwin or MinGW OS isOSCygMing()579 bool isOSCygMing() const { 580 return isWindowsCygwinEnvironment() || isWindowsGNUEnvironment(); 581 } 582 583 /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment. isOSMSVCRT()584 bool isOSMSVCRT() const { 585 return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() || 586 isWindowsItaniumEnvironment(); 587 } 588 589 /// Tests whether the OS is NaCl (Native Client) isOSNaCl()590 bool isOSNaCl() const { 591 return getOS() == Triple::NaCl; 592 } 593 594 /// Tests whether the OS is Linux. isOSLinux()595 bool isOSLinux() const { 596 return getOS() == Triple::Linux; 597 } 598 599 /// Tests whether the OS is kFreeBSD. isOSKFreeBSD()600 bool isOSKFreeBSD() const { 601 return getOS() == Triple::KFreeBSD; 602 } 603 604 /// Tests whether the OS is Hurd. isOSHurd()605 bool isOSHurd() const { 606 return getOS() == Triple::Hurd; 607 } 608 609 /// Tests whether the OS is WASI. isOSWASI()610 bool isOSWASI() const { 611 return getOS() == Triple::WASI; 612 } 613 614 /// Tests whether the OS is Emscripten. isOSEmscripten()615 bool isOSEmscripten() const { 616 return getOS() == Triple::Emscripten; 617 } 618 619 /// Tests whether the OS uses glibc. isOSGlibc()620 bool isOSGlibc() const { 621 return (getOS() == Triple::Linux || getOS() == Triple::KFreeBSD || 622 getOS() == Triple::Hurd) && 623 !isAndroid(); 624 } 625 626 /// Tests whether the OS is AIX. isOSAIX()627 bool isOSAIX() const { 628 return getOS() == Triple::AIX; 629 } 630 631 /// Tests whether the OS uses the ELF binary format. isOSBinFormatELF()632 bool isOSBinFormatELF() const { 633 return getObjectFormat() == Triple::ELF; 634 } 635 636 /// Tests whether the OS uses the COFF binary format. isOSBinFormatCOFF()637 bool isOSBinFormatCOFF() const { 638 return getObjectFormat() == Triple::COFF; 639 } 640 641 /// Tests whether the OS uses the GOFF binary format. isOSBinFormatGOFF()642 bool isOSBinFormatGOFF() const { return getObjectFormat() == Triple::GOFF; } 643 644 /// Tests whether the environment is MachO. isOSBinFormatMachO()645 bool isOSBinFormatMachO() const { 646 return getObjectFormat() == Triple::MachO; 647 } 648 649 /// Tests whether the OS uses the Wasm binary format. isOSBinFormatWasm()650 bool isOSBinFormatWasm() const { 651 return getObjectFormat() == Triple::Wasm; 652 } 653 654 /// Tests whether the OS uses the XCOFF binary format. isOSBinFormatXCOFF()655 bool isOSBinFormatXCOFF() const { 656 return getObjectFormat() == Triple::XCOFF; 657 } 658 659 /// Tests whether the target is the PS4 CPU isPS4CPU()660 bool isPS4CPU() const { 661 return getArch() == Triple::x86_64 && 662 getVendor() == Triple::SCEI && 663 getOS() == Triple::PS4; 664 } 665 666 /// Tests whether the target is the PS4 platform isPS4()667 bool isPS4() const { 668 return getVendor() == Triple::SCEI && 669 getOS() == Triple::PS4; 670 } 671 672 /// Tests whether the target is Android isAndroid()673 bool isAndroid() const { return getEnvironment() == Triple::Android; } 674 isAndroidVersionLT(unsigned Major)675 bool isAndroidVersionLT(unsigned Major) const { 676 assert(isAndroid() && "Not an Android triple!"); 677 678 unsigned Env[3]; 679 getEnvironmentVersion(Env[0], Env[1], Env[2]); 680 681 // 64-bit targets did not exist before API level 21 (Lollipop). 682 if (isArch64Bit() && Env[0] < 21) 683 Env[0] = 21; 684 685 return Env[0] < Major; 686 } 687 688 /// Tests whether the environment is musl-libc isMusl()689 bool isMusl() const { 690 return getEnvironment() == Triple::Musl || 691 getEnvironment() == Triple::MuslEABI || 692 getEnvironment() == Triple::MuslEABIHF || 693 getEnvironment() == Triple::MuslX32; 694 } 695 696 /// Tests whether the target is SPIR (32- or 64-bit). isSPIR()697 bool isSPIR() const { 698 return getArch() == Triple::spir || getArch() == Triple::spir64; 699 } 700 701 /// Tests whether the target is NVPTX (32- or 64-bit). isNVPTX()702 bool isNVPTX() const { 703 return getArch() == Triple::nvptx || getArch() == Triple::nvptx64; 704 } 705 706 /// Tests whether the target is AMDGCN isAMDGCN()707 bool isAMDGCN() const { return getArch() == Triple::amdgcn; } 708 isAMDGPU()709 bool isAMDGPU() const { 710 return getArch() == Triple::r600 || getArch() == Triple::amdgcn; 711 } 712 713 /// Tests whether the target is Thumb (little and big endian). isThumb()714 bool isThumb() const { 715 return getArch() == Triple::thumb || getArch() == Triple::thumbeb; 716 } 717 718 /// Tests whether the target is ARM (little and big endian). isARM()719 bool isARM() const { 720 return getArch() == Triple::arm || getArch() == Triple::armeb; 721 } 722 723 /// Tests whether the target is AArch64 (little and big endian). isAArch64()724 bool isAArch64() const { 725 return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be || 726 getArch() == Triple::aarch64_32; 727 } 728 729 /// Tests whether the target is AArch64 and pointers are the size specified by 730 /// \p PointerWidth. isAArch64(int PointerWidth)731 bool isAArch64(int PointerWidth) const { 732 assert(PointerWidth == 64 || PointerWidth == 32); 733 if (!isAArch64()) 734 return false; 735 return getArch() == Triple::aarch64_32 || 736 getEnvironment() == Triple::GNUILP32 737 ? PointerWidth == 32 738 : PointerWidth == 64; 739 } 740 741 /// Tests whether the target is MIPS 32-bit (little and big endian). isMIPS32()742 bool isMIPS32() const { 743 return getArch() == Triple::mips || getArch() == Triple::mipsel; 744 } 745 746 /// Tests whether the target is MIPS 64-bit (little and big endian). isMIPS64()747 bool isMIPS64() const { 748 return getArch() == Triple::mips64 || getArch() == Triple::mips64el; 749 } 750 751 /// Tests whether the target is MIPS (little and big endian, 32- or 64-bit). isMIPS()752 bool isMIPS() const { 753 return isMIPS32() || isMIPS64(); 754 } 755 756 /// Tests whether the target is PowerPC (32- or 64-bit LE or BE). isPPC()757 bool isPPC() const { 758 return getArch() == Triple::ppc || getArch() == Triple::ppc64 || 759 getArch() == Triple::ppcle || getArch() == Triple::ppc64le; 760 } 761 762 /// Tests whether the target is 32-bit PowerPC (little and big endian). isPPC32()763 bool isPPC32() const { 764 return getArch() == Triple::ppc || getArch() == Triple::ppcle; 765 } 766 767 /// Tests whether the target is 64-bit PowerPC (little and big endian). isPPC64()768 bool isPPC64() const { 769 return getArch() == Triple::ppc64 || getArch() == Triple::ppc64le; 770 } 771 772 /// Tests whether the target is RISC-V (32- and 64-bit). isRISCV()773 bool isRISCV() const { 774 return getArch() == Triple::riscv32 || getArch() == Triple::riscv64; 775 } 776 777 /// Tests whether the target is SystemZ. isSystemZ()778 bool isSystemZ() const { 779 return getArch() == Triple::systemz; 780 } 781 782 /// Tests whether the target is x86 (32- or 64-bit). isX86()783 bool isX86() const { 784 return getArch() == Triple::x86 || getArch() == Triple::x86_64; 785 } 786 787 /// Tests whether the target is VE isVE()788 bool isVE() const { 789 return getArch() == Triple::ve; 790 } 791 792 /// Tests whether the target is wasm (32- and 64-bit). isWasm()793 bool isWasm() const { 794 return getArch() == Triple::wasm32 || getArch() == Triple::wasm64; 795 } 796 797 // Tests whether the target is CSKY isCSKY()798 bool isCSKY() const { 799 return getArch() == Triple::csky; 800 } 801 802 /// Tests whether the target is the Apple "arm64e" AArch64 subarch. isArm64e()803 bool isArm64e() const { 804 return getArch() == Triple::aarch64 && 805 getSubArch() == Triple::AArch64SubArch_arm64e; 806 } 807 808 /// Tests whether the target supports comdat supportsCOMDAT()809 bool supportsCOMDAT() const { 810 return !(isOSBinFormatMachO() || isOSBinFormatXCOFF()); 811 } 812 813 /// Tests whether the target uses emulated TLS as default. hasDefaultEmulatedTLS()814 bool hasDefaultEmulatedTLS() const { 815 return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment(); 816 } 817 818 /// Tests whether the target uses -data-sections as default. hasDefaultDataSections()819 bool hasDefaultDataSections() const { 820 return isOSBinFormatXCOFF() || isWasm(); 821 } 822 823 /// Tests if the environment supports dllimport/export annotations. hasDLLImportExport()824 bool hasDLLImportExport() const { return isOSWindows() || isPS4CPU(); } 825 826 /// @} 827 /// @name Mutators 828 /// @{ 829 830 /// setArch - Set the architecture (first) component of the triple 831 /// to a known type. 832 void setArch(ArchType Kind); 833 834 /// setVendor - Set the vendor (second) component of the triple to a 835 /// known type. 836 void setVendor(VendorType Kind); 837 838 /// setOS - Set the operating system (third) component of the triple 839 /// to a known type. 840 void setOS(OSType Kind); 841 842 /// setEnvironment - Set the environment (fourth) component of the triple 843 /// to a known type. 844 void setEnvironment(EnvironmentType Kind); 845 846 /// setObjectFormat - Set the object file format 847 void setObjectFormat(ObjectFormatType Kind); 848 849 /// setTriple - Set all components to the new triple \p Str. 850 void setTriple(const Twine &Str); 851 852 /// setArchName - Set the architecture (first) component of the 853 /// triple by name. 854 void setArchName(StringRef Str); 855 856 /// setVendorName - Set the vendor (second) component of the triple 857 /// by name. 858 void setVendorName(StringRef Str); 859 860 /// setOSName - Set the operating system (third) component of the 861 /// triple by name. 862 void setOSName(StringRef Str); 863 864 /// setEnvironmentName - Set the optional environment (fourth) 865 /// component of the triple by name. 866 void setEnvironmentName(StringRef Str); 867 868 /// setOSAndEnvironmentName - Set the operating system and optional 869 /// environment components with a single string. 870 void setOSAndEnvironmentName(StringRef Str); 871 872 /// @} 873 /// @name Helpers to build variants of a particular triple. 874 /// @{ 875 876 /// Form a triple with a 32-bit variant of the current architecture. 877 /// 878 /// This can be used to move across "families" of architectures where useful. 879 /// 880 /// \returns A new triple with a 32-bit architecture or an unknown 881 /// architecture if no such variant can be found. 882 llvm::Triple get32BitArchVariant() const; 883 884 /// Form a triple with a 64-bit variant of the current architecture. 885 /// 886 /// This can be used to move across "families" of architectures where useful. 887 /// 888 /// \returns A new triple with a 64-bit architecture or an unknown 889 /// architecture if no such variant can be found. 890 llvm::Triple get64BitArchVariant() const; 891 892 /// Form a triple with a big endian variant of the current architecture. 893 /// 894 /// This can be used to move across "families" of architectures where useful. 895 /// 896 /// \returns A new triple with a big endian architecture or an unknown 897 /// architecture if no such variant can be found. 898 llvm::Triple getBigEndianArchVariant() const; 899 900 /// Form a triple with a little endian variant of the current architecture. 901 /// 902 /// This can be used to move across "families" of architectures where useful. 903 /// 904 /// \returns A new triple with a little endian architecture or an unknown 905 /// architecture if no such variant can be found. 906 llvm::Triple getLittleEndianArchVariant() const; 907 908 /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting. 909 /// 910 /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty 911 /// string then the triple's arch name is used. 912 StringRef getARMCPUForArch(StringRef Arch = StringRef()) const; 913 914 /// Tests whether the target triple is little endian. 915 /// 916 /// \returns true if the triple is little endian, false otherwise. 917 bool isLittleEndian() const; 918 919 /// Test whether target triples are compatible. 920 bool isCompatibleWith(const Triple &Other) const; 921 922 /// Merge target triples. 923 std::string merge(const Triple &Other) const; 924 925 /// Some platforms have different minimum supported OS versions that 926 /// varies by the architecture specified in the triple. This function 927 /// returns the minimum supported OS version for this triple if one an exists, 928 /// or an invalid version tuple if this triple doesn't have one. 929 VersionTuple getMinimumSupportedOSVersion() const; 930 931 /// @} 932 /// @name Static helpers for IDs. 933 /// @{ 934 935 /// getArchTypeName - Get the canonical name for the \p Kind architecture. 936 static StringRef getArchTypeName(ArchType Kind); 937 938 /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind 939 /// architecture. This is the prefix used by the architecture specific 940 /// builtins, and is suitable for passing to \see 941 /// Intrinsic::getIntrinsicForGCCBuiltin(). 942 /// 943 /// \return - The architecture prefix, or 0 if none is defined. 944 static StringRef getArchTypePrefix(ArchType Kind); 945 946 /// getVendorTypeName - Get the canonical name for the \p Kind vendor. 947 static StringRef getVendorTypeName(VendorType Kind); 948 949 /// getOSTypeName - Get the canonical name for the \p Kind operating system. 950 static StringRef getOSTypeName(OSType Kind); 951 952 /// getEnvironmentTypeName - Get the canonical name for the \p Kind 953 /// environment. 954 static StringRef getEnvironmentTypeName(EnvironmentType Kind); 955 956 /// @} 957 /// @name Static helpers for converting alternate architecture names. 958 /// @{ 959 960 /// getArchTypeForLLVMName - The canonical type for the given LLVM 961 /// architecture name (e.g., "x86"). 962 static ArchType getArchTypeForLLVMName(StringRef Str); 963 964 /// @} 965 966 /// Returns a canonicalized OS version number for the specified OS. 967 static VersionTuple getCanonicalVersionForOS(OSType OSKind, 968 const VersionTuple &Version); 969 }; 970 971 } // End llvm namespace 972 973 974 #endif 975