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     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