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