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