contrib/llvm/include/llvm/ADT/Triple.h

   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     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     LastArchType = renderscript64
  99   };
 100   enum SubArchType {
 101     NoSubArch,
 102
 103     ARMSubArch_v8_5a,
 104     ARMSubArch_v8_4a,
 105     ARMSubArch_v8_3a,
 106     ARMSubArch_v8_2a,
 107     ARMSubArch_v8_1a,
 108     ARMSubArch_v8,
 109     ARMSubArch_v8r,
 110     ARMSubArch_v8m_baseline,
 111     ARMSubArch_v8m_mainline,
 112     ARMSubArch_v7,
 113     ARMSubArch_v7em,
 114     ARMSubArch_v7m,
 115     ARMSubArch_v7s,
 116     ARMSubArch_v7k,
 117     ARMSubArch_v7ve,
 118     ARMSubArch_v6,
 119     ARMSubArch_v6m,
 120     ARMSubArch_v6k,
 121     ARMSubArch_v6t2,
 122     ARMSubArch_v5,
 123     ARMSubArch_v5te,
 124     ARMSubArch_v4t,
 125
 126     KalimbaSubArch_v3,
 127     KalimbaSubArch_v4,
 128     KalimbaSubArch_v5,
 129
 130     MipsSubArch_r6
 131   };
 132   enum VendorType {
 133     UnknownVendor,
 134
 135     Apple,
 136     PC,
 137     SCEI,
 138     BGP,
 139     BGQ,
 140     Freescale,
 141     IBM,
 142     ImaginationTechnologies,
 143     MipsTechnologies,
 144     NVIDIA,
 145     CSR,
 146     Myriad,
 147     AMD,
 148     Mesa,
 149     SUSE,
 150     OpenEmbedded,
 151     LastVendorType = OpenEmbedded
 152   };
 153   enum OSType {
 154     UnknownOS,
 155
 156     Ananas,
 157     CloudABI,
 158     Darwin,
 159     DragonFly,
 160     FreeBSD,
 161     Fuchsia,
 162     IOS,
 163     KFreeBSD,
 164     Linux,
 165     Lv2,        // PS3
 166     MacOSX,
 167     NetBSD,
 168     OpenBSD,
 169     Solaris,
 170     Win32,
 171     Haiku,
 172     Minix,
 173     RTEMS,
 174     NaCl,       // Native Client
 175     CNK,        // BG/P Compute-Node Kernel
 176     AIX,
 177     CUDA,       // NVIDIA CUDA
 178     NVCL,       // NVIDIA OpenCL
 179     AMDHSA,     // AMD HSA Runtime
 180     PS4,
 181     ELFIAMCU,
 182     TvOS,       // Apple tvOS
 183     WatchOS,    // Apple watchOS
 184     Mesa3D,
 185     Contiki,
 186     AMDPAL,     // AMD PAL Runtime
 187     HermitCore, // HermitCore Unikernel/Multikernel
 188     Hurd,       // GNU/Hurd
 189     WASI,       // Experimental WebAssembly OS
 190     LastOSType = WASI
 191   };
 192   enum EnvironmentType {
 193     UnknownEnvironment,
 194
 195     GNU,
 196     GNUABIN32,
 197     GNUABI64,
 198     GNUEABI,
 199     GNUEABIHF,
 200     GNUX32,
 201     CODE16,
 202     EABI,
 203     EABIHF,
 204     Android,
 205     Musl,
 206     MuslEABI,
 207     MuslEABIHF,
 208
 209     MSVC,
 210     Itanium,
 211     Cygnus,
 212     CoreCLR,
 213     Simulator,  // Simulator variants of other systems, e.g., Apple's iOS
 214     LastEnvironmentType = Simulator
 215   };
 216   enum ObjectFormatType {
 217     UnknownObjectFormat,
 218
 219     COFF,
 220     ELF,
 221     MachO,
 222     Wasm,
 223   };
 224
 225 private:
 226   std::string Data;
 227
 228   /// The parsed arch type.
 229   ArchType Arch;
 230
 231   /// The parsed subarchitecture type.
 232   SubArchType SubArch;
 233
 234   /// The parsed vendor type.
 235   VendorType Vendor;
 236
 237   /// The parsed OS type.
 238   OSType OS;
 239
 240   /// The parsed Environment type.
 241   EnvironmentType Environment;
 242
 243   /// The object format type.
 244   ObjectFormatType ObjectFormat;
 245
 246 public:
 247   /// @name Constructors
 248   /// @{
 249
 250   /// Default constructor is the same as an empty string and leaves all
 251   /// triple fields unknown.
 252   Triple()
 253       : Data(), Arch(), SubArch(), Vendor(), OS(), Environment(),
 254         ObjectFormat() {}
 255
 256   explicit Triple(const Twine &Str);
 257   Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr);
 258   Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
 259          const Twine &EnvironmentStr);
 260
 261   bool operator==(const Triple &Other) const {
 262     return Arch == Other.Arch && SubArch == Other.SubArch &&
 263            Vendor == Other.Vendor && OS == Other.OS &&
 264            Environment == Other.Environment &&
 265            ObjectFormat == Other.ObjectFormat;
 266   }
 267
 268   bool operator!=(const Triple &Other) const {
 269     return !(*this == Other);
 270   }
 271
 272   /// @}
 273   /// @name Normalization
 274   /// @{
 275
 276   /// normalize - Turn an arbitrary machine specification into the canonical
 277   /// triple form (or something sensible that the Triple class understands if
 278   /// nothing better can reasonably be done).  In particular, it handles the
 279   /// common case in which otherwise valid components are in the wrong order.
 280   static std::string normalize(StringRef Str);
 281
 282   /// Return the normalized form of this triple's string.
 283   std::string normalize() const { return normalize(Data); }
 284
 285   /// @}
 286   /// @name Typed Component Access
 287   /// @{
 288
 289   /// getArch - Get the parsed architecture type of this triple.
 290   ArchType getArch() const { return Arch; }
 291
 292   /// getSubArch - get the parsed subarchitecture type for this triple.
 293   SubArchType getSubArch() const { return SubArch; }
 294
 295   /// getVendor - Get the parsed vendor type of this triple.
 296   VendorType getVendor() const { return Vendor; }
 297
 298   /// getOS - Get the parsed operating system type of this triple.
 299   OSType getOS() const { return OS; }
 300
 301   /// hasEnvironment - Does this triple have the optional environment
 302   /// (fourth) component?
 303   bool hasEnvironment() const {
 304     return getEnvironmentName() != "";
 305   }
 306
 307   /// getEnvironment - Get the parsed environment type of this triple.
 308   EnvironmentType getEnvironment() const { return Environment; }
 309
 310   /// Parse the version number from the OS name component of the
 311   /// triple, if present.
 312   ///
 313   /// For example, "fooos1.2.3" would return (1, 2, 3).
 314   ///
 315   /// If an entry is not defined, it will be returned as 0.
 316   void getEnvironmentVersion(unsigned &Major, unsigned &Minor,
 317                              unsigned &Micro) const;
 318
 319   /// getFormat - Get the object format for this triple.
 320   ObjectFormatType getObjectFormat() const { return ObjectFormat; }
 321
 322   /// getOSVersion - Parse the version number from the OS name component of the
 323   /// triple, if present.
 324   ///
 325   /// For example, "fooos1.2.3" would return (1, 2, 3).
 326   ///
 327   /// If an entry is not defined, it will be returned as 0.
 328   void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const;
 329
 330   /// getOSMajorVersion - Return just the major version number, this is
 331   /// specialized because it is a common query.
 332   unsigned getOSMajorVersion() const {
 333     unsigned Maj, Min, Micro;
 334     getOSVersion(Maj, Min, Micro);
 335     return Maj;
 336   }
 337
 338   /// getMacOSXVersion - Parse the version number as with getOSVersion and then
 339   /// translate generic "darwin" versions to the corresponding OS X versions.
 340   /// This may also be called with IOS triples but the OS X version number is
 341   /// just set to a constant 10.4.0 in that case.  Returns true if successful.
 342   bool getMacOSXVersion(unsigned &Major, unsigned &Minor,
 343                         unsigned &Micro) const;
 344
 345   /// getiOSVersion - Parse the version number as with getOSVersion.  This should
 346   /// only be called with IOS or generic triples.
 347   void getiOSVersion(unsigned &Major, unsigned &Minor,
 348                      unsigned &Micro) const;
 349
 350   /// getWatchOSVersion - Parse the version number as with getOSVersion.  This
 351   /// should only be called with WatchOS or generic triples.
 352   void getWatchOSVersion(unsigned &Major, unsigned &Minor,
 353                          unsigned &Micro) const;
 354
 355   /// @}
 356   /// @name Direct Component Access
 357   /// @{
 358
 359   const std::string &str() const { return Data; }
 360
 361   const std::string &getTriple() const { return Data; }
 362
 363   /// getArchName - Get the architecture (first) component of the
 364   /// triple.
 365   StringRef getArchName() const;
 366
 367   /// getVendorName - Get the vendor (second) component of the triple.
 368   StringRef getVendorName() const;
 369
 370   /// getOSName - Get the operating system (third) component of the
 371   /// triple.
 372   StringRef getOSName() const;
 373
 374   /// getEnvironmentName - Get the optional environment (fourth)
 375   /// component of the triple, or "" if empty.
 376   StringRef getEnvironmentName() const;
 377
 378   /// getOSAndEnvironmentName - Get the operating system and optional
 379   /// environment components as a single string (separated by a '-'
 380   /// if the environment component is present).
 381   StringRef getOSAndEnvironmentName() const;
 382
 383   /// @}
 384   /// @name Convenience Predicates
 385   /// @{
 386
 387   /// Test whether the architecture is 64-bit
 388   ///
 389   /// Note that this tests for 64-bit pointer width, and nothing else. Note
 390   /// that we intentionally expose only three predicates, 64-bit, 32-bit, and
 391   /// 16-bit. The inner details of pointer width for particular architectures
 392   /// is not summed up in the triple, and so only a coarse grained predicate
 393   /// system is provided.
 394   bool isArch64Bit() const;
 395
 396   /// Test whether the architecture is 32-bit
 397   ///
 398   /// Note that this tests for 32-bit pointer width, and nothing else.
 399   bool isArch32Bit() const;
 400
 401   /// Test whether the architecture is 16-bit
 402   ///
 403   /// Note that this tests for 16-bit pointer width, and nothing else.
 404   bool isArch16Bit() const;
 405
 406   /// isOSVersionLT - Helper function for doing comparisons against version
 407   /// numbers included in the target triple.
 408   bool isOSVersionLT(unsigned Major, unsigned Minor = 0,
 409                      unsigned Micro = 0) const {
 410     unsigned LHS[3];
 411     getOSVersion(LHS[0], LHS[1], LHS[2]);
 412
 413     if (LHS[0] != Major)
 414       return LHS[0] < Major;
 415     if (LHS[1] != Minor)
 416       return LHS[1] < Minor;
 417     if (LHS[2] != Micro)
 418       return LHS[1] < Micro;
 419
 420     return false;
 421   }
 422
 423   bool isOSVersionLT(const Triple &Other) const {
 424     unsigned RHS[3];
 425     Other.getOSVersion(RHS[0], RHS[1], RHS[2]);
 426     return isOSVersionLT(RHS[0], RHS[1], RHS[2]);
 427   }
 428
 429   /// isMacOSXVersionLT - Comparison function for checking OS X version
 430   /// compatibility, which handles supporting skewed version numbering schemes
 431   /// used by the "darwin" triples.
 432   bool isMacOSXVersionLT(unsigned Major, unsigned Minor = 0,
 433                          unsigned Micro = 0) const {
 434     assert(isMacOSX() && "Not an OS X triple!");
 435
 436     // If this is OS X, expect a sane version number.
 437     if (getOS() == Triple::MacOSX)
 438       return isOSVersionLT(Major, Minor, Micro);
 439
 440     // Otherwise, compare to the "Darwin" number.
 441     assert(Major == 10 && "Unexpected major version");
 442     return isOSVersionLT(Minor + 4, Micro, 0);
 443   }
 444
 445   /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
 446   /// "darwin" and "osx" as OS X triples.
 447   bool isMacOSX() const {
 448     return getOS() == Triple::Darwin || getOS() == Triple::MacOSX;
 449   }
 450
 451   /// Is this an iOS triple.
 452   /// Note: This identifies tvOS as a variant of iOS. If that ever
 453   /// changes, i.e., if the two operating systems diverge or their version
 454   /// numbers get out of sync, that will need to be changed.
 455   /// watchOS has completely different version numbers so it is not included.
 456   bool isiOS() const {
 457     return getOS() == Triple::IOS || isTvOS();
 458   }
 459
 460   /// Is this an Apple tvOS triple.
 461   bool isTvOS() const {
 462     return getOS() == Triple::TvOS;
 463   }
 464
 465   /// Is this an Apple watchOS triple.
 466   bool isWatchOS() const {
 467     return getOS() == Triple::WatchOS;
 468   }
 469
 470   bool isWatchABI() const {
 471     return getSubArch() == Triple::ARMSubArch_v7k;
 472   }
 473
 474   /// isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
 475   bool isOSDarwin() const {
 476     return isMacOSX() || isiOS() || isWatchOS();
 477   }
 478
 479   bool isSimulatorEnvironment() const {
 480     return getEnvironment() == Triple::Simulator;
 481   }
 482
 483   bool isOSNetBSD() const {
 484     return getOS() == Triple::NetBSD;
 485   }
 486
 487   bool isOSOpenBSD() const {
 488     return getOS() == Triple::OpenBSD;
 489   }
 490
 491   bool isOSFreeBSD() const {
 492     return getOS() == Triple::FreeBSD;
 493   }
 494
 495   bool isOSFuchsia() const {
 496     return getOS() == Triple::Fuchsia;
 497   }
 498
 499   bool isOSDragonFly() const { return getOS() == Triple::DragonFly; }
 500
 501   bool isOSSolaris() const {
 502     return getOS() == Triple::Solaris;
 503   }
 504
 505   bool isOSIAMCU() const {
 506     return getOS() == Triple::ELFIAMCU;
 507   }
 508
 509   bool isOSUnknown() const { return getOS() == Triple::UnknownOS; }
 510
 511   bool isGNUEnvironment() const {
 512     EnvironmentType Env = getEnvironment();
 513     return Env == Triple::GNU || Env == Triple::GNUABIN32 ||
 514            Env == Triple::GNUABI64 || Env == Triple::GNUEABI ||
 515            Env == Triple::GNUEABIHF || Env == Triple::GNUX32;
 516   }
 517
 518   bool isOSContiki() const {
 519     return getOS() == Triple::Contiki;
 520   }
 521
 522   /// Tests whether the OS is Haiku.
 523   bool isOSHaiku() const {
 524     return getOS() == Triple::Haiku;
 525   }
 526
 527   /// Checks if the environment could be MSVC.
 528   bool isWindowsMSVCEnvironment() const {
 529     return getOS() == Triple::Win32 &&
 530            (getEnvironment() == Triple::UnknownEnvironment ||
 531             getEnvironment() == Triple::MSVC);
 532   }
 533
 534   /// Checks if the environment is MSVC.
 535   bool isKnownWindowsMSVCEnvironment() const {
 536     return getOS() == Triple::Win32 && getEnvironment() == Triple::MSVC;
 537   }
 538
 539   bool isWindowsCoreCLREnvironment() const {
 540     return getOS() == Triple::Win32 && getEnvironment() == Triple::CoreCLR;
 541   }
 542
 543   bool isWindowsItaniumEnvironment() const {
 544     return getOS() == Triple::Win32 && getEnvironment() == Triple::Itanium;
 545   }
 546
 547   bool isWindowsCygwinEnvironment() const {
 548     return getOS() == Triple::Win32 && getEnvironment() == Triple::Cygnus;
 549   }
 550
 551   bool isWindowsGNUEnvironment() const {
 552     return getOS() == Triple::Win32 && getEnvironment() == Triple::GNU;
 553   }
 554
 555   /// Tests for either Cygwin or MinGW OS
 556   bool isOSCygMing() const {
 557     return isWindowsCygwinEnvironment() || isWindowsGNUEnvironment();
 558   }
 559
 560   /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment.
 561   bool isOSMSVCRT() const {
 562     return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() ||
 563            isWindowsItaniumEnvironment();
 564   }
 565
 566   /// Tests whether the OS is Windows.
 567   bool isOSWindows() const {
 568     return getOS() == Triple::Win32;
 569   }
 570
 571   /// Tests whether the OS is NaCl (Native Client)
 572   bool isOSNaCl() const {
 573     return getOS() == Triple::NaCl;
 574   }
 575
 576   /// Tests whether the OS is Linux.
 577   bool isOSLinux() const {
 578     return getOS() == Triple::Linux;
 579   }
 580
 581   /// Tests whether the OS is kFreeBSD.
 582   bool isOSKFreeBSD() const {
 583     return getOS() == Triple::KFreeBSD;
 584   }
 585
 586   /// Tests whether the OS is Hurd.
 587   bool isOSHurd() const {
 588     return getOS() == Triple::Hurd;
 589   }
 590
 591   /// Tests whether the OS is WASI.
 592   bool isOSWASI() const {
 593     return getOS() == Triple::WASI;
 594   }
 595
 596   /// Tests whether the OS uses glibc.
 597   bool isOSGlibc() const {
 598     return (getOS() == Triple::Linux || getOS() == Triple::KFreeBSD ||
 599             getOS() == Triple::Hurd) &&
 600            !isAndroid();
 601   }
 602
 603   /// Tests whether the OS uses the ELF binary format.
 604   bool isOSBinFormatELF() const {
 605     return getObjectFormat() == Triple::ELF;
 606   }
 607
 608   /// Tests whether the OS uses the COFF binary format.
 609   bool isOSBinFormatCOFF() const {
 610     return getObjectFormat() == Triple::COFF;
 611   }
 612
 613   /// Tests whether the environment is MachO.
 614   bool isOSBinFormatMachO() const {
 615     return getObjectFormat() == Triple::MachO;
 616   }
 617
 618   /// Tests whether the OS uses the Wasm binary format.
 619   bool isOSBinFormatWasm() const {
 620     return getObjectFormat() == Triple::Wasm;
 621   }
 622
 623   /// Tests whether the target is the PS4 CPU
 624   bool isPS4CPU() const {
 625     return getArch() == Triple::x86_64 &&
 626            getVendor() == Triple::SCEI &&
 627            getOS() == Triple::PS4;
 628   }
 629
 630   /// Tests whether the target is the PS4 platform
 631   bool isPS4() const {
 632     return getVendor() == Triple::SCEI &&
 633            getOS() == Triple::PS4;
 634   }
 635
 636   /// Tests whether the target is Android
 637   bool isAndroid() const { return getEnvironment() == Triple::Android; }
 638
 639   bool isAndroidVersionLT(unsigned Major) const {
 640     assert(isAndroid() && "Not an Android triple!");
 641
 642     unsigned Env[3];
 643     getEnvironmentVersion(Env[0], Env[1], Env[2]);
 644
 645     // 64-bit targets did not exist before API level 21 (Lollipop).
 646     if (isArch64Bit() && Env[0] < 21)
 647       Env[0] = 21;
 648
 649     return Env[0] < Major;
 650   }
 651
 652   /// Tests whether the environment is musl-libc
 653   bool isMusl() const {
 654     return getEnvironment() == Triple::Musl ||
 655            getEnvironment() == Triple::MuslEABI ||
 656            getEnvironment() == Triple::MuslEABIHF;
 657   }
 658
 659   /// Tests whether the target is NVPTX (32- or 64-bit).
 660   bool isNVPTX() const {
 661     return getArch() == Triple::nvptx || getArch() == Triple::nvptx64;
 662   }
 663
 664   /// Tests whether the target is Thumb (little and big endian).
 665   bool isThumb() const {
 666     return getArch() == Triple::thumb || getArch() == Triple::thumbeb;
 667   }
 668
 669   /// Tests whether the target is ARM (little and big endian).
 670   bool isARM() const {
 671     return getArch() == Triple::arm || getArch() == Triple::armeb;
 672   }
 673
 674   /// Tests whether the target is AArch64 (little and big endian).
 675   bool isAArch64() const {
 676     return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be;
 677   }
 678
 679   /// Tests whether the target is MIPS 32-bit (little and big endian).
 680   bool isMIPS32() const {
 681     return getArch() == Triple::mips || getArch() == Triple::mipsel;
 682   }
 683
 684   /// Tests whether the target is MIPS 64-bit (little and big endian).
 685   bool isMIPS64() const {
 686     return getArch() == Triple::mips64 || getArch() == Triple::mips64el;
 687   }
 688
 689   /// Tests whether the target is MIPS (little and big endian, 32- or 64-bit).
 690   bool isMIPS() const {
 691     return isMIPS32() || isMIPS64();
 692   }
 693
 694   /// Tests whether the target supports comdat
 695   bool supportsCOMDAT() const {
 696     return !isOSBinFormatMachO();
 697   }
 698
 699   /// Tests whether the target uses emulated TLS as default.
 700   bool hasDefaultEmulatedTLS() const {
 701     return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment();
 702   }
 703
 704   /// @}
 705   /// @name Mutators
 706   /// @{
 707
 708   /// setArch - Set the architecture (first) component of the triple
 709   /// to a known type.
 710   void setArch(ArchType Kind);
 711
 712   /// setVendor - Set the vendor (second) component of the triple to a
 713   /// known type.
 714   void setVendor(VendorType Kind);
 715
 716   /// setOS - Set the operating system (third) component of the triple
 717   /// to a known type.
 718   void setOS(OSType Kind);
 719
 720   /// setEnvironment - Set the environment (fourth) component of the triple
 721   /// to a known type.
 722   void setEnvironment(EnvironmentType Kind);
 723
 724   /// setObjectFormat - Set the object file format
 725   void setObjectFormat(ObjectFormatType Kind);
 726
 727   /// setTriple - Set all components to the new triple \p Str.
 728   void setTriple(const Twine &Str);
 729
 730   /// setArchName - Set the architecture (first) component of the
 731   /// triple by name.
 732   void setArchName(StringRef Str);
 733
 734   /// setVendorName - Set the vendor (second) component of the triple
 735   /// by name.
 736   void setVendorName(StringRef Str);
 737
 738   /// setOSName - Set the operating system (third) component of the
 739   /// triple by name.
 740   void setOSName(StringRef Str);
 741
 742   /// setEnvironmentName - Set the optional environment (fourth)
 743   /// component of the triple by name.
 744   void setEnvironmentName(StringRef Str);
 745
 746   /// setOSAndEnvironmentName - Set the operating system and optional
 747   /// environment components with a single string.
 748   void setOSAndEnvironmentName(StringRef Str);
 749
 750   /// @}
 751   /// @name Helpers to build variants of a particular triple.
 752   /// @{
 753
 754   /// Form a triple with a 32-bit variant of the current architecture.
 755   ///
 756   /// This can be used to move across "families" of architectures where useful.
 757   ///
 758   /// \returns A new triple with a 32-bit architecture or an unknown
 759   ///          architecture if no such variant can be found.
 760   llvm::Triple get32BitArchVariant() const;
 761
 762   /// Form a triple with a 64-bit variant of the current architecture.
 763   ///
 764   /// This can be used to move across "families" of architectures where useful.
 765   ///
 766   /// \returns A new triple with a 64-bit architecture or an unknown
 767   ///          architecture if no such variant can be found.
 768   llvm::Triple get64BitArchVariant() const;
 769
 770   /// Form a triple with a big endian variant of the current architecture.
 771   ///
 772   /// This can be used to move across "families" of architectures where useful.
 773   ///
 774   /// \returns A new triple with a big endian architecture or an unknown
 775   ///          architecture if no such variant can be found.
 776   llvm::Triple getBigEndianArchVariant() const;
 777
 778   /// Form a triple with a little endian variant of the current architecture.
 779   ///
 780   /// This can be used to move across "families" of architectures where useful.
 781   ///
 782   /// \returns A new triple with a little endian architecture or an unknown
 783   ///          architecture if no such variant can be found.
 784   llvm::Triple getLittleEndianArchVariant() const;
 785
 786   /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
 787   ///
 788   /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty
 789   /// string then the triple's arch name is used.
 790   StringRef getARMCPUForArch(StringRef Arch = StringRef()) const;
 791
 792   /// Tests whether the target triple is little endian.
 793   ///
 794   /// \returns true if the triple is little endian, false otherwise.
 795   bool isLittleEndian() const;
 796
 797   /// Test whether target triples are compatible.
 798   bool isCompatibleWith(const Triple &Other) const;
 799
 800   /// Merge target triples.
 801   std::string merge(const Triple &Other) const;
 802
 803   /// @}
 804   /// @name Static helpers for IDs.
 805   /// @{
 806
 807   /// getArchTypeName - Get the canonical name for the \p Kind architecture.
 808   static StringRef getArchTypeName(ArchType Kind);
 809
 810   /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind
 811   /// architecture. This is the prefix used by the architecture specific
 812   /// builtins, and is suitable for passing to \see
 813   /// Intrinsic::getIntrinsicForGCCBuiltin().
 814   ///
 815   /// \return - The architecture prefix, or 0 if none is defined.
 816   static StringRef getArchTypePrefix(ArchType Kind);
 817
 818   /// getVendorTypeName - Get the canonical name for the \p Kind vendor.
 819   static StringRef getVendorTypeName(VendorType Kind);
 820
 821   /// getOSTypeName - Get the canonical name for the \p Kind operating system.
 822   static StringRef getOSTypeName(OSType Kind);
 823
 824   /// getEnvironmentTypeName - Get the canonical name for the \p Kind
 825   /// environment.
 826   static StringRef getEnvironmentTypeName(EnvironmentType Kind);
 827
 828   /// @}
 829   /// @name Static helpers for converting alternate architecture names.
 830   /// @{
 831
 832   /// getArchTypeForLLVMName - The canonical type for the given LLVM
 833   /// architecture name (e.g., "x86").
 834   static ArchType getArchTypeForLLVMName(StringRef Str);
 835
 836   /// @}
 837 };
 838
 839 } // End llvm namespace
 840
 841
 842 #endif