1 //===-- llvm/ADT/Triple.h - Target triple helper class ----------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef LLVM_ADT_TRIPLE_H 11 #define LLVM_ADT_TRIPLE_H 12 13 #include "llvm/ADT/Twine.h" 14 15 // Some system headers or GCC predefined macros conflict with identifiers in 16 // this file. Undefine them here. 17 #undef NetBSD 18 #undef mips 19 #undef sparc 20 21 namespace llvm { 22 23 /// Triple - Helper class for working with autoconf configuration names. For 24 /// historical reasons, we also call these 'triples' (they used to contain 25 /// exactly three fields). 26 /// 27 /// Configuration names are strings in the canonical form: 28 /// ARCHITECTURE-VENDOR-OPERATING_SYSTEM 29 /// or 30 /// ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT 31 /// 32 /// This class is used for clients which want to support arbitrary 33 /// configuration names, but also want to implement certain special 34 /// behavior for particular configurations. This class isolates the mapping 35 /// from the components of the configuration name to well known IDs. 36 /// 37 /// At its core the Triple class is designed to be a wrapper for a triple 38 /// string; the constructor does not change or normalize the triple string. 39 /// Clients that need to handle the non-canonical triples that users often 40 /// specify should use the normalize method. 41 /// 42 /// See autoconf/config.guess for a glimpse into what configuration names 43 /// look like in practice. 44 class Triple { 45 public: 46 enum ArchType { 47 UnknownArch, 48 49 arm, // ARM (little endian): arm, armv.*, xscale 50 armeb, // ARM (big endian): armeb 51 aarch64, // AArch64 (little endian): aarch64 52 aarch64_be, // AArch64 (big endian): aarch64_be 53 avr, // AVR: Atmel AVR microcontroller 54 bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) 55 bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian) 56 hexagon, // Hexagon: hexagon 57 mips, // MIPS: mips, mipsallegrex 58 mipsel, // MIPSEL: mipsel, mipsallegrexel 59 mips64, // MIPS64: mips64 60 mips64el, // MIPS64EL: mips64el 61 msp430, // MSP430: msp430 62 ppc, // PPC: powerpc 63 ppc64, // PPC64: powerpc64, ppu 64 ppc64le, // PPC64LE: powerpc64le 65 r600, // R600: AMD GPUs HD2XXX - HD6XXX 66 amdgcn, // AMDGCN: AMD GCN GPUs 67 sparc, // Sparc: sparc 68 sparcv9, // Sparcv9: Sparcv9 69 sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant 70 systemz, // SystemZ: s390x 71 tce, // TCE (http://tce.cs.tut.fi/): tce 72 thumb, // Thumb (little endian): thumb, thumbv.* 73 thumbeb, // Thumb (big endian): thumbeb 74 x86, // X86: i[3-9]86 75 x86_64, // X86-64: amd64, x86_64 76 xcore, // XCore: xcore 77 nvptx, // NVPTX: 32-bit 78 nvptx64, // NVPTX: 64-bit 79 le32, // le32: generic little-endian 32-bit CPU (PNaCl) 80 le64, // le64: generic little-endian 64-bit CPU (PNaCl) 81 amdil, // AMDIL 82 amdil64, // AMDIL with 64-bit pointers 83 hsail, // AMD HSAIL 84 hsail64, // AMD HSAIL with 64-bit pointers 85 spir, // SPIR: standard portable IR for OpenCL 32-bit version 86 spir64, // SPIR: standard portable IR for OpenCL 64-bit version 87 kalimba, // Kalimba: generic kalimba 88 shave, // SHAVE: Movidius vector VLIW processors 89 wasm32, // WebAssembly with 32-bit pointers 90 wasm64, // WebAssembly with 64-bit pointers 91 LastArchType = wasm64 92 }; 93 enum SubArchType { 94 NoSubArch, 95 96 ARMSubArch_v8_2a, 97 ARMSubArch_v8_1a, 98 ARMSubArch_v8, 99 ARMSubArch_v7, 100 ARMSubArch_v7em, 101 ARMSubArch_v7m, 102 ARMSubArch_v7s, 103 ARMSubArch_v7k, 104 ARMSubArch_v6, 105 ARMSubArch_v6m, 106 ARMSubArch_v6k, 107 ARMSubArch_v6t2, 108 ARMSubArch_v5, 109 ARMSubArch_v5te, 110 ARMSubArch_v4t, 111 112 KalimbaSubArch_v3, 113 KalimbaSubArch_v4, 114 KalimbaSubArch_v5 115 }; 116 enum VendorType { 117 UnknownVendor, 118 119 Apple, 120 PC, 121 SCEI, 122 BGP, 123 BGQ, 124 Freescale, 125 IBM, 126 ImaginationTechnologies, 127 MipsTechnologies, 128 NVIDIA, 129 CSR, 130 Myriad, 131 LastVendorType = Myriad 132 }; 133 enum OSType { 134 UnknownOS, 135 136 CloudABI, 137 Darwin, 138 DragonFly, 139 FreeBSD, 140 IOS, 141 KFreeBSD, 142 Linux, 143 Lv2, // PS3 144 MacOSX, 145 NetBSD, 146 OpenBSD, 147 Solaris, 148 Win32, 149 Haiku, 150 Minix, 151 RTEMS, 152 NaCl, // Native Client 153 CNK, // BG/P Compute-Node Kernel 154 Bitrig, 155 AIX, 156 CUDA, // NVIDIA CUDA 157 NVCL, // NVIDIA OpenCL 158 AMDHSA, // AMD HSA Runtime 159 PS4, 160 ELFIAMCU, 161 TvOS, // Apple tvOS 162 WatchOS, // Apple watchOS 163 LastOSType = WatchOS 164 }; 165 enum EnvironmentType { 166 UnknownEnvironment, 167 168 GNU, 169 GNUEABI, 170 GNUEABIHF, 171 GNUX32, 172 CODE16, 173 EABI, 174 EABIHF, 175 Android, 176 177 MSVC, 178 Itanium, 179 Cygnus, 180 AMDOpenCL, 181 CoreCLR, 182 LastEnvironmentType = CoreCLR 183 }; 184 enum ObjectFormatType { 185 UnknownObjectFormat, 186 187 COFF, 188 ELF, 189 MachO, 190 }; 191 192 private: 193 std::string Data; 194 195 /// The parsed arch type. 196 ArchType Arch; 197 198 /// The parsed subarchitecture type. 199 SubArchType SubArch; 200 201 /// The parsed vendor type. 202 VendorType Vendor; 203 204 /// The parsed OS type. 205 OSType OS; 206 207 /// The parsed Environment type. 208 EnvironmentType Environment; 209 210 /// The object format type. 211 ObjectFormatType ObjectFormat; 212 213 public: 214 /// @name Constructors 215 /// @{ 216 217 /// Default constructor is the same as an empty string and leaves all 218 /// triple fields unknown. 219 Triple() : Data(), Arch(), Vendor(), OS(), Environment(), ObjectFormat() {} 220 221 explicit Triple(const Twine &Str); 222 Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr); 223 Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr, 224 const Twine &EnvironmentStr); 225 226 bool operator==(const Triple &Other) const { 227 return Arch == Other.Arch && SubArch == Other.SubArch && 228 Vendor == Other.Vendor && OS == Other.OS && 229 Environment == Other.Environment && 230 ObjectFormat == Other.ObjectFormat; 231 } 232 233 /// @} 234 /// @name Normalization 235 /// @{ 236 237 /// normalize - Turn an arbitrary machine specification into the canonical 238 /// triple form (or something sensible that the Triple class understands if 239 /// nothing better can reasonably be done). In particular, it handles the 240 /// common case in which otherwise valid components are in the wrong order. 241 static std::string normalize(StringRef Str); 242 243 /// Return the normalized form of this triple's string. 244 std::string normalize() const { return normalize(Data); } 245 246 /// @} 247 /// @name Typed Component Access 248 /// @{ 249 250 /// getArch - Get the parsed architecture type of this triple. 251 ArchType getArch() const { return Arch; } 252 253 /// getSubArch - get the parsed subarchitecture type for this triple. 254 SubArchType getSubArch() const { return SubArch; } 255 256 /// getVendor - Get the parsed vendor type of this triple. 257 VendorType getVendor() const { return Vendor; } 258 259 /// getOS - Get the parsed operating system type of this triple. 260 OSType getOS() const { return OS; } 261 262 /// hasEnvironment - Does this triple have the optional environment 263 /// (fourth) component? 264 bool hasEnvironment() const { 265 return getEnvironmentName() != ""; 266 } 267 268 /// getEnvironment - Get the parsed environment type of this triple. 269 EnvironmentType getEnvironment() const { return Environment; } 270 271 /// Parse the version number from the OS name component of the 272 /// triple, if present. 273 /// 274 /// For example, "fooos1.2.3" would return (1, 2, 3). 275 /// 276 /// If an entry is not defined, it will be returned as 0. 277 void getEnvironmentVersion(unsigned &Major, unsigned &Minor, 278 unsigned &Micro) const; 279 280 /// getFormat - Get the object format for this triple. 281 ObjectFormatType getObjectFormat() const { return ObjectFormat; } 282 283 /// getOSVersion - Parse the version number from the OS name component of the 284 /// triple, if present. 285 /// 286 /// For example, "fooos1.2.3" would return (1, 2, 3). 287 /// 288 /// If an entry is not defined, it will be returned as 0. 289 void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const; 290 291 /// getOSMajorVersion - Return just the major version number, this is 292 /// specialized because it is a common query. 293 unsigned getOSMajorVersion() const { 294 unsigned Maj, Min, Micro; 295 getOSVersion(Maj, Min, Micro); 296 return Maj; 297 } 298 299 /// getMacOSXVersion - Parse the version number as with getOSVersion and then 300 /// translate generic "darwin" versions to the corresponding OS X versions. 301 /// This may also be called with IOS triples but the OS X version number is 302 /// just set to a constant 10.4.0 in that case. Returns true if successful. 303 bool getMacOSXVersion(unsigned &Major, unsigned &Minor, 304 unsigned &Micro) const; 305 306 /// getiOSVersion - Parse the version number as with getOSVersion. This should 307 /// only be called with IOS or generic triples. 308 void getiOSVersion(unsigned &Major, unsigned &Minor, 309 unsigned &Micro) const; 310 311 /// getWatchOSVersion - Parse the version number as with getOSVersion. This 312 /// should only be called with WatchOS or generic triples. 313 void getWatchOSVersion(unsigned &Major, unsigned &Minor, 314 unsigned &Micro) const; 315 316 /// @} 317 /// @name Direct Component Access 318 /// @{ 319 320 const std::string &str() const { return Data; } 321 322 const std::string &getTriple() const { return Data; } 323 324 /// getArchName - Get the architecture (first) component of the 325 /// triple. 326 StringRef getArchName() const; 327 328 /// getVendorName - Get the vendor (second) component of the triple. 329 StringRef getVendorName() const; 330 331 /// getOSName - Get the operating system (third) component of the 332 /// triple. 333 StringRef getOSName() const; 334 335 /// getEnvironmentName - Get the optional environment (fourth) 336 /// component of the triple, or "" if empty. 337 StringRef getEnvironmentName() const; 338 339 /// getOSAndEnvironmentName - Get the operating system and optional 340 /// environment components as a single string (separated by a '-' 341 /// if the environment component is present). 342 StringRef getOSAndEnvironmentName() const; 343 344 /// @} 345 /// @name Convenience Predicates 346 /// @{ 347 348 /// Test whether the architecture is 64-bit 349 /// 350 /// Note that this tests for 64-bit pointer width, and nothing else. Note 351 /// that we intentionally expose only three predicates, 64-bit, 32-bit, and 352 /// 16-bit. The inner details of pointer width for particular architectures 353 /// is not summed up in the triple, and so only a coarse grained predicate 354 /// system is provided. 355 bool isArch64Bit() const; 356 357 /// Test whether the architecture is 32-bit 358 /// 359 /// Note that this tests for 32-bit pointer width, and nothing else. 360 bool isArch32Bit() const; 361 362 /// Test whether the architecture is 16-bit 363 /// 364 /// Note that this tests for 16-bit pointer width, and nothing else. 365 bool isArch16Bit() const; 366 367 /// isOSVersionLT - Helper function for doing comparisons against version 368 /// numbers included in the target triple. 369 bool isOSVersionLT(unsigned Major, unsigned Minor = 0, 370 unsigned Micro = 0) const { 371 unsigned LHS[3]; 372 getOSVersion(LHS[0], LHS[1], LHS[2]); 373 374 if (LHS[0] != Major) 375 return LHS[0] < Major; 376 if (LHS[1] != Minor) 377 return LHS[1] < Minor; 378 if (LHS[2] != Micro) 379 return LHS[1] < Micro; 380 381 return false; 382 } 383 384 bool isOSVersionLT(const Triple &Other) const { 385 unsigned RHS[3]; 386 Other.getOSVersion(RHS[0], RHS[1], RHS[2]); 387 return isOSVersionLT(RHS[0], RHS[1], RHS[2]); 388 } 389 390 /// isMacOSXVersionLT - Comparison function for checking OS X version 391 /// compatibility, which handles supporting skewed version numbering schemes 392 /// used by the "darwin" triples. 393 unsigned isMacOSXVersionLT(unsigned Major, unsigned Minor = 0, 394 unsigned Micro = 0) const { 395 assert(isMacOSX() && "Not an OS X triple!"); 396 397 // If this is OS X, expect a sane version number. 398 if (getOS() == Triple::MacOSX) 399 return isOSVersionLT(Major, Minor, Micro); 400 401 // Otherwise, compare to the "Darwin" number. 402 assert(Major == 10 && "Unexpected major version"); 403 return isOSVersionLT(Minor + 4, Micro, 0); 404 } 405 406 /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both 407 /// "darwin" and "osx" as OS X triples. 408 bool isMacOSX() const { 409 return getOS() == Triple::Darwin || getOS() == Triple::MacOSX; 410 } 411 412 /// Is this an iOS triple. 413 /// Note: This identifies tvOS as a variant of iOS. If that ever 414 /// changes, i.e., if the two operating systems diverge or their version 415 /// numbers get out of sync, that will need to be changed. 416 /// watchOS has completely different version numbers so it is not included. 417 bool isiOS() const { 418 return getOS() == Triple::IOS || isTvOS(); 419 } 420 421 /// Is this an Apple tvOS triple. 422 bool isTvOS() const { 423 return getOS() == Triple::TvOS; 424 } 425 426 /// Is this an Apple watchOS triple. 427 bool isWatchOS() const { 428 return getOS() == Triple::WatchOS; 429 } 430 431 /// isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS). 432 bool isOSDarwin() const { 433 return isMacOSX() || isiOS() || isWatchOS(); 434 } 435 436 bool isOSNetBSD() const { 437 return getOS() == Triple::NetBSD; 438 } 439 440 bool isOSOpenBSD() const { 441 return getOS() == Triple::OpenBSD; 442 } 443 444 bool isOSFreeBSD() const { 445 return getOS() == Triple::FreeBSD; 446 } 447 448 bool isOSDragonFly() const { return getOS() == Triple::DragonFly; } 449 450 bool isOSSolaris() const { 451 return getOS() == Triple::Solaris; 452 } 453 454 bool isOSBitrig() const { 455 return getOS() == Triple::Bitrig; 456 } 457 458 bool isOSIAMCU() const { 459 return getOS() == Triple::ELFIAMCU; 460 } 461 462 /// Checks if the environment could be MSVC. 463 bool isWindowsMSVCEnvironment() const { 464 return getOS() == Triple::Win32 && 465 (getEnvironment() == Triple::UnknownEnvironment || 466 getEnvironment() == Triple::MSVC); 467 } 468 469 /// Checks if the environment is MSVC. 470 bool isKnownWindowsMSVCEnvironment() const { 471 return getOS() == Triple::Win32 && getEnvironment() == Triple::MSVC; 472 } 473 474 bool isWindowsCoreCLREnvironment() const { 475 return getOS() == Triple::Win32 && getEnvironment() == Triple::CoreCLR; 476 } 477 478 bool isWindowsItaniumEnvironment() const { 479 return getOS() == Triple::Win32 && getEnvironment() == Triple::Itanium; 480 } 481 482 bool isWindowsCygwinEnvironment() const { 483 return getOS() == Triple::Win32 && getEnvironment() == Triple::Cygnus; 484 } 485 486 bool isWindowsGNUEnvironment() const { 487 return getOS() == Triple::Win32 && getEnvironment() == Triple::GNU; 488 } 489 490 /// Tests for either Cygwin or MinGW OS 491 bool isOSCygMing() const { 492 return isWindowsCygwinEnvironment() || isWindowsGNUEnvironment(); 493 } 494 495 /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment. 496 bool isOSMSVCRT() const { 497 return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() || 498 isWindowsItaniumEnvironment(); 499 } 500 501 /// Tests whether the OS is Windows. 502 bool isOSWindows() const { 503 return getOS() == Triple::Win32; 504 } 505 506 /// Tests whether the OS is NaCl (Native Client) 507 bool isOSNaCl() const { 508 return getOS() == Triple::NaCl; 509 } 510 511 /// Tests whether the OS is Linux. 512 bool isOSLinux() const { 513 return getOS() == Triple::Linux; 514 } 515 516 /// Tests whether the OS uses the ELF binary format. 517 bool isOSBinFormatELF() const { 518 return getObjectFormat() == Triple::ELF; 519 } 520 521 /// Tests whether the OS uses the COFF binary format. 522 bool isOSBinFormatCOFF() const { 523 return getObjectFormat() == Triple::COFF; 524 } 525 526 /// Tests whether the environment is MachO. 527 bool isOSBinFormatMachO() const { 528 return getObjectFormat() == Triple::MachO; 529 } 530 531 /// Tests whether the target is the PS4 CPU 532 bool isPS4CPU() const { 533 return getArch() == Triple::x86_64 && 534 getVendor() == Triple::SCEI && 535 getOS() == Triple::PS4; 536 } 537 538 /// Tests whether the target is the PS4 platform 539 bool isPS4() const { 540 return getVendor() == Triple::SCEI && 541 getOS() == Triple::PS4; 542 } 543 544 /// Tests whether the target is Android 545 bool isAndroid() const { return getEnvironment() == Triple::Android; } 546 547 /// @} 548 /// @name Mutators 549 /// @{ 550 551 /// setArch - Set the architecture (first) component of the triple 552 /// to a known type. 553 void setArch(ArchType Kind); 554 555 /// setVendor - Set the vendor (second) component of the triple to a 556 /// known type. 557 void setVendor(VendorType Kind); 558 559 /// setOS - Set the operating system (third) component of the triple 560 /// to a known type. 561 void setOS(OSType Kind); 562 563 /// setEnvironment - Set the environment (fourth) component of the triple 564 /// to a known type. 565 void setEnvironment(EnvironmentType Kind); 566 567 /// setObjectFormat - Set the object file format 568 void setObjectFormat(ObjectFormatType Kind); 569 570 /// setTriple - Set all components to the new triple \p Str. 571 void setTriple(const Twine &Str); 572 573 /// setArchName - Set the architecture (first) component of the 574 /// triple by name. 575 void setArchName(StringRef Str); 576 577 /// setVendorName - Set the vendor (second) component of the triple 578 /// by name. 579 void setVendorName(StringRef Str); 580 581 /// setOSName - Set the operating system (third) component of the 582 /// triple by name. 583 void setOSName(StringRef Str); 584 585 /// setEnvironmentName - Set the optional environment (fourth) 586 /// component of the triple by name. 587 void setEnvironmentName(StringRef Str); 588 589 /// setOSAndEnvironmentName - Set the operating system and optional 590 /// environment components with a single string. 591 void setOSAndEnvironmentName(StringRef Str); 592 593 /// @} 594 /// @name Helpers to build variants of a particular triple. 595 /// @{ 596 597 /// Form a triple with a 32-bit variant of the current architecture. 598 /// 599 /// This can be used to move across "families" of architectures where useful. 600 /// 601 /// \returns A new triple with a 32-bit architecture or an unknown 602 /// architecture if no such variant can be found. 603 llvm::Triple get32BitArchVariant() const; 604 605 /// Form a triple with a 64-bit variant of the current architecture. 606 /// 607 /// This can be used to move across "families" of architectures where useful. 608 /// 609 /// \returns A new triple with a 64-bit architecture or an unknown 610 /// architecture if no such variant can be found. 611 llvm::Triple get64BitArchVariant() const; 612 613 /// Form a triple with a big endian variant of the current architecture. 614 /// 615 /// This can be used to move across "families" of architectures where useful. 616 /// 617 /// \returns A new triple with a big endian architecture or an unknown 618 /// architecture if no such variant can be found. 619 llvm::Triple getBigEndianArchVariant() const; 620 621 /// Form a triple with a little endian variant of the current architecture. 622 /// 623 /// This can be used to move across "families" of architectures where useful. 624 /// 625 /// \returns A new triple with a little endian architecture or an unknown 626 /// architecture if no such variant can be found. 627 llvm::Triple getLittleEndianArchVariant() const; 628 629 /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting. 630 /// 631 /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty 632 /// string then the triple's arch name is used. 633 StringRef getARMCPUForArch(StringRef Arch = StringRef()) const; 634 635 /// @} 636 /// @name Static helpers for IDs. 637 /// @{ 638 639 /// getArchTypeName - Get the canonical name for the \p Kind architecture. 640 static const char *getArchTypeName(ArchType Kind); 641 642 /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind 643 /// architecture. This is the prefix used by the architecture specific 644 /// builtins, and is suitable for passing to \see 645 /// Intrinsic::getIntrinsicForGCCBuiltin(). 646 /// 647 /// \return - The architecture prefix, or 0 if none is defined. 648 static const char *getArchTypePrefix(ArchType Kind); 649 650 /// getVendorTypeName - Get the canonical name for the \p Kind vendor. 651 static const char *getVendorTypeName(VendorType Kind); 652 653 /// getOSTypeName - Get the canonical name for the \p Kind operating system. 654 static const char *getOSTypeName(OSType Kind); 655 656 /// getEnvironmentTypeName - Get the canonical name for the \p Kind 657 /// environment. 658 static const char *getEnvironmentTypeName(EnvironmentType Kind); 659 660 /// @} 661 /// @name Static helpers for converting alternate architecture names. 662 /// @{ 663 664 /// getArchTypeForLLVMName - The canonical type for the given LLVM 665 /// architecture name (e.g., "x86"). 666 static ArchType getArchTypeForLLVMName(StringRef Str); 667 668 /// @} 669 }; 670 671 } // End llvm namespace 672 673 674 #endif 675
