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