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