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
22class VersionTuple;
23
24/// Triple - Helper class for working with autoconf configuration names. For
25/// historical reasons, we also call these 'triples' (they used to contain
26/// exactly three fields).
27///
28/// Configuration names are strings in the canonical form:
29///   ARCHITECTURE-VENDOR-OPERATING_SYSTEM
30/// or
31///   ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT
32///
33/// This class is used for clients which want to support arbitrary
34/// configuration names, but also want to implement certain special
35/// behavior for particular configurations. This class isolates the mapping
36/// from the components of the configuration name to well known IDs.
37///
38/// At its core the Triple class is designed to be a wrapper for a triple
39/// string; the constructor does not change or normalize the triple string.
40/// Clients that need to handle the non-canonical triples that users often
41/// specify should use the normalize method.
42///
43/// See autoconf/config.guess for a glimpse into what configuration names
44/// look like in practice.
45class Triple {
46public:
47  enum ArchType {
48    UnknownArch,
49
50    arm,            // ARM (little endian): arm, armv.*, xscale
51    armeb,          // ARM (big endian): armeb
52    aarch64,        // AArch64 (little endian): aarch64
53    aarch64_be,     // AArch64 (big endian): aarch64_be
54    aarch64_32,     // AArch64 (little endian) ILP32: aarch64_32
55    arc,            // ARC: Synopsys ARC
56    avr,            // AVR: Atmel AVR microcontroller
57    bpfel,          // eBPF or extended BPF or 64-bit BPF (little endian)
58    bpfeb,          // eBPF or extended BPF or 64-bit BPF (big endian)
59    csky,           // CSKY: csky
60    hexagon,        // Hexagon: hexagon
61    m68k,           // M68k: Motorola 680x0 family
62    mips,           // MIPS: mips, mipsallegrex, mipsr6
63    mipsel,         // MIPSEL: mipsel, mipsallegrexe, mipsr6el
64    mips64,         // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
65    mips64el,       // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
66    msp430,         // MSP430: msp430
67    ppc,            // PPC: powerpc
68    ppcle,          // PPCLE: powerpc (little endian)
69    ppc64,          // PPC64: powerpc64, ppu
70    ppc64le,        // PPC64LE: powerpc64le
71    r600,           // R600: AMD GPUs HD2XXX - HD6XXX
72    amdgcn,         // AMDGCN: AMD GCN GPUs
73    riscv32,        // RISC-V (32-bit): riscv32
74    riscv64,        // RISC-V (64-bit): riscv64
75    sparc,          // Sparc: sparc
76    sparcv9,        // Sparcv9: Sparcv9
77    sparcel,        // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
78    systemz,        // SystemZ: s390x
79    tce,            // TCE (http://tce.cs.tut.fi/): tce
80    tcele,          // TCE little endian (http://tce.cs.tut.fi/): tcele
81    thumb,          // Thumb (little endian): thumb, thumbv.*
82    thumbeb,        // Thumb (big endian): thumbeb
83    x86,            // X86: i[3-9]86
84    x86_64,         // X86-64: amd64, x86_64
85    xcore,          // XCore: xcore
86    nvptx,          // NVPTX: 32-bit
87    nvptx64,        // NVPTX: 64-bit
88    le32,           // le32: generic little-endian 32-bit CPU (PNaCl)
89    le64,           // le64: generic little-endian 64-bit CPU (PNaCl)
90    amdil,          // AMDIL
91    amdil64,        // AMDIL with 64-bit pointers
92    hsail,          // AMD HSAIL
93    hsail64,        // AMD HSAIL with 64-bit pointers
94    spir,           // SPIR: standard portable IR for OpenCL 32-bit version
95    spir64,         // SPIR: standard portable IR for OpenCL 64-bit version
96    kalimba,        // Kalimba: generic kalimba
97    shave,          // SHAVE: Movidius vector VLIW processors
98    lanai,          // Lanai: Lanai 32-bit
99    wasm32,         // WebAssembly with 32-bit pointers
100    wasm64,         // WebAssembly with 64-bit pointers
101    renderscript32, // 32-bit RenderScript
102    renderscript64, // 64-bit RenderScript
103    ve,             // NEC SX-Aurora Vector Engine
104    LastArchType = ve
105  };
106  enum SubArchType {
107    NoSubArch,
108
109    ARMSubArch_v8_7a,
110    ARMSubArch_v8_6a,
111    ARMSubArch_v8_5a,
112    ARMSubArch_v8_4a,
113    ARMSubArch_v8_3a,
114    ARMSubArch_v8_2a,
115    ARMSubArch_v8_1a,
116    ARMSubArch_v8,
117    ARMSubArch_v8r,
118    ARMSubArch_v8m_baseline,
119    ARMSubArch_v8m_mainline,
120    ARMSubArch_v8_1m_mainline,
121    ARMSubArch_v7,
122    ARMSubArch_v7em,
123    ARMSubArch_v7m,
124    ARMSubArch_v7s,
125    ARMSubArch_v7k,
126    ARMSubArch_v7ve,
127    ARMSubArch_v6,
128    ARMSubArch_v6m,
129    ARMSubArch_v6k,
130    ARMSubArch_v6t2,
131    ARMSubArch_v5,
132    ARMSubArch_v5te,
133    ARMSubArch_v4t,
134
135    AArch64SubArch_arm64e,
136
137    KalimbaSubArch_v3,
138    KalimbaSubArch_v4,
139    KalimbaSubArch_v5,
140
141    MipsSubArch_r6,
142
143    PPCSubArch_spe
144  };
145  enum VendorType {
146    UnknownVendor,
147
148    Apple,
149    PC,
150    SCEI,
151    Freescale,
152    IBM,
153    ImaginationTechnologies,
154    MipsTechnologies,
155    NVIDIA,
156    CSR,
157    Myriad,
158    AMD,
159    Mesa,
160    SUSE,
161    OpenEmbedded,
162    LastVendorType = OpenEmbedded
163  };
164  enum OSType {
165    UnknownOS,
166
167    Ananas,
168    CloudABI,
169    Darwin,
170    DragonFly,
171    FreeBSD,
172    Fuchsia,
173    IOS,
174    KFreeBSD,
175    Linux,
176    Lv2,        // PS3
177    MacOSX,
178    NetBSD,
179    OpenBSD,
180    Solaris,
181    Win32,
182    ZOS,
183    Haiku,
184    Minix,
185    RTEMS,
186    NaCl,       // Native Client
187    AIX,
188    CUDA,       // NVIDIA CUDA
189    NVCL,       // NVIDIA OpenCL
190    AMDHSA,     // AMD HSA Runtime
191    PS4,
192    ELFIAMCU,
193    TvOS,       // Apple tvOS
194    WatchOS,    // Apple watchOS
195    Mesa3D,
196    Contiki,
197    AMDPAL,     // AMD PAL Runtime
198    HermitCore, // HermitCore Unikernel/Multikernel
199    Hurd,       // GNU/Hurd
200    WASI,       // Experimental WebAssembly OS
201    Emscripten,
202    LastOSType = Emscripten
203  };
204  enum EnvironmentType {
205    UnknownEnvironment,
206
207    GNU,
208    GNUABIN32,
209    GNUABI64,
210    GNUEABI,
211    GNUEABIHF,
212    GNUX32,
213    GNUILP32,
214    CODE16,
215    EABI,
216    EABIHF,
217    Android,
218    Musl,
219    MuslEABI,
220    MuslEABIHF,
221    MuslX32,
222
223    MSVC,
224    Itanium,
225    Cygnus,
226    CoreCLR,
227    Simulator, // Simulator variants of other systems, e.g., Apple's iOS
228    MacABI, // Mac Catalyst variant of Apple's iOS deployment target.
229    LastEnvironmentType = MacABI
230  };
231  enum ObjectFormatType {
232    UnknownObjectFormat,
233
234    COFF,
235    ELF,
236    GOFF,
237    MachO,
238    Wasm,
239    XCOFF,
240  };
241
242private:
243  std::string Data;
244
245  /// The parsed arch type.
246  ArchType Arch;
247
248  /// The parsed subarchitecture type.
249  SubArchType SubArch;
250
251  /// The parsed vendor type.
252  VendorType Vendor;
253
254  /// The parsed OS type.
255  OSType OS;
256
257  /// The parsed Environment type.
258  EnvironmentType Environment;
259
260  /// The object format type.
261  ObjectFormatType ObjectFormat;
262
263public:
264  /// @name Constructors
265  /// @{
266
267  /// Default constructor is the same as an empty string and leaves all
268  /// triple fields unknown.
269  Triple()
270      : Data(), Arch(), SubArch(), Vendor(), OS(), Environment(),
271        ObjectFormat() {}
272
273  explicit Triple(const Twine &Str);
274  Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr);
275  Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
276         const Twine &EnvironmentStr);
277
278  bool operator==(const Triple &Other) const {
279    return Arch == Other.Arch && SubArch == Other.SubArch &&
280           Vendor == Other.Vendor && OS == Other.OS &&
281           Environment == Other.Environment &&
282           ObjectFormat == Other.ObjectFormat;
283  }
284
285  bool operator!=(const Triple &Other) const {
286    return !(*this == Other);
287  }
288
289  /// @}
290  /// @name Normalization
291  /// @{
292
293  /// normalize - Turn an arbitrary machine specification into the canonical
294  /// triple form (or something sensible that the Triple class understands if
295  /// nothing better can reasonably be done).  In particular, it handles the
296  /// common case in which otherwise valid components are in the wrong order.
297  static std::string normalize(StringRef Str);
298
299  /// Return the normalized form of this triple's string.
300  std::string normalize() const { return normalize(Data); }
301
302  /// @}
303  /// @name Typed Component Access
304  /// @{
305
306  /// getArch - Get the parsed architecture type of this triple.
307  ArchType getArch() const { return Arch; }
308
309  /// getSubArch - get the parsed subarchitecture type for this triple.
310  SubArchType getSubArch() const { return SubArch; }
311
312  /// getVendor - Get the parsed vendor type of this triple.
313  VendorType getVendor() const { return Vendor; }
314
315  /// getOS - Get the parsed operating system type of this triple.
316  OSType getOS() const { return OS; }
317
318  /// hasEnvironment - Does this triple have the optional environment
319  /// (fourth) component?
320  bool hasEnvironment() const {
321    return getEnvironmentName() != "";
322  }
323
324  /// getEnvironment - Get the parsed environment type of this triple.
325  EnvironmentType getEnvironment() const { return Environment; }
326
327  /// Parse the version number from the OS name component of the
328  /// triple, if present.
329  ///
330  /// For example, "fooos1.2.3" would return (1, 2, 3).
331  ///
332  /// If an entry is not defined, it will be returned as 0.
333  void getEnvironmentVersion(unsigned &Major, unsigned &Minor,
334                             unsigned &Micro) const;
335
336  /// getFormat - Get the object format for this triple.
337  ObjectFormatType getObjectFormat() const { return ObjectFormat; }
338
339  /// getOSVersion - Parse the version number from the OS name component of the
340  /// triple, if present.
341  ///
342  /// For example, "fooos1.2.3" would return (1, 2, 3).
343  ///
344  /// If an entry is not defined, it will be returned as 0.
345  void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const;
346
347  /// getOSMajorVersion - Return just the major version number, this is
348  /// specialized because it is a common query.
349  unsigned getOSMajorVersion() const {
350    unsigned Maj, Min, Micro;
351    getOSVersion(Maj, Min, Micro);
352    return Maj;
353  }
354
355  /// getMacOSXVersion - Parse the version number as with getOSVersion and then
356  /// translate generic "darwin" versions to the corresponding OS X versions.
357  /// This may also be called with IOS triples but the OS X version number is
358  /// just set to a constant 10.4.0 in that case.  Returns true if successful.
359  bool getMacOSXVersion(unsigned &Major, unsigned &Minor,
360                        unsigned &Micro) const;
361
362  /// getiOSVersion - Parse the version number as with getOSVersion.  This should
363  /// only be called with IOS or generic triples.
364  void getiOSVersion(unsigned &Major, unsigned &Minor,
365                     unsigned &Micro) const;
366
367  /// getWatchOSVersion - Parse the version number as with getOSVersion.  This
368  /// should only be called with WatchOS or generic triples.
369  void getWatchOSVersion(unsigned &Major, unsigned &Minor,
370                         unsigned &Micro) const;
371
372  /// @}
373  /// @name Direct Component Access
374  /// @{
375
376  const std::string &str() const { return Data; }
377
378  const std::string &getTriple() const { return Data; }
379
380  /// getArchName - Get the architecture (first) component of the
381  /// triple.
382  StringRef getArchName() const;
383
384  /// getVendorName - Get the vendor (second) component of the triple.
385  StringRef getVendorName() const;
386
387  /// getOSName - Get the operating system (third) component of the
388  /// triple.
389  StringRef getOSName() const;
390
391  /// getEnvironmentName - Get the optional environment (fourth)
392  /// component of the triple, or "" if empty.
393  StringRef getEnvironmentName() const;
394
395  /// getOSAndEnvironmentName - Get the operating system and optional
396  /// environment components as a single string (separated by a '-'
397  /// if the environment component is present).
398  StringRef getOSAndEnvironmentName() const;
399
400  /// @}
401  /// @name Convenience Predicates
402  /// @{
403
404  /// Test whether the architecture is 64-bit
405  ///
406  /// Note that this tests for 64-bit pointer width, and nothing else. Note
407  /// that we intentionally expose only three predicates, 64-bit, 32-bit, and
408  /// 16-bit. The inner details of pointer width for particular architectures
409  /// is not summed up in the triple, and so only a coarse grained predicate
410  /// system is provided.
411  bool isArch64Bit() const;
412
413  /// Test whether the architecture is 32-bit
414  ///
415  /// Note that this tests for 32-bit pointer width, and nothing else.
416  bool isArch32Bit() const;
417
418  /// Test whether the architecture is 16-bit
419  ///
420  /// Note that this tests for 16-bit pointer width, and nothing else.
421  bool isArch16Bit() const;
422
423  /// isOSVersionLT - Helper function for doing comparisons against version
424  /// numbers included in the target triple.
425  bool isOSVersionLT(unsigned Major, unsigned Minor = 0,
426                     unsigned Micro = 0) const {
427    unsigned LHS[3];
428    getOSVersion(LHS[0], LHS[1], LHS[2]);
429
430    if (LHS[0] != Major)
431      return LHS[0] < Major;
432    if (LHS[1] != Minor)
433      return LHS[1] < Minor;
434    if (LHS[2] != Micro)
435      return LHS[2] < Micro;
436
437    return false;
438  }
439
440  bool isOSVersionLT(const Triple &Other) const {
441    unsigned RHS[3];
442    Other.getOSVersion(RHS[0], RHS[1], RHS[2]);
443    return isOSVersionLT(RHS[0], RHS[1], RHS[2]);
444  }
445
446  /// isMacOSXVersionLT - Comparison function for checking OS X version
447  /// compatibility, which handles supporting skewed version numbering schemes
448  /// used by the "darwin" triples.
449  bool isMacOSXVersionLT(unsigned Major, unsigned Minor = 0,
450                         unsigned Micro = 0) const;
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  bool isOSzOS() const { return getOS() == Triple::ZOS; }
482
483  /// isOSDarwin - Is this a "Darwin" OS (macOS, iOS, tvOS or watchOS).
484  bool isOSDarwin() const {
485    return isMacOSX() || isiOS() || isWatchOS();
486  }
487
488  bool isSimulatorEnvironment() const {
489    return getEnvironment() == Triple::Simulator;
490  }
491
492  bool isMacCatalystEnvironment() const {
493    return getEnvironment() == Triple::MacABI;
494  }
495
496  /// Returns true for targets that run on a macOS machine.
497  bool isTargetMachineMac() const {
498    return isMacOSX() || (isOSDarwin() && (isSimulatorEnvironment() ||
499                                           isMacCatalystEnvironment()));
500  }
501
502  bool isOSNetBSD() const {
503    return getOS() == Triple::NetBSD;
504  }
505
506  bool isOSOpenBSD() const {
507    return getOS() == Triple::OpenBSD;
508  }
509
510  bool isOSFreeBSD() const {
511    return getOS() == Triple::FreeBSD;
512  }
513
514  bool isOSFuchsia() const {
515    return getOS() == Triple::Fuchsia;
516  }
517
518  bool isOSDragonFly() const { return getOS() == Triple::DragonFly; }
519
520  bool isOSSolaris() const {
521    return getOS() == Triple::Solaris;
522  }
523
524  bool isOSIAMCU() const {
525    return getOS() == Triple::ELFIAMCU;
526  }
527
528  bool isOSUnknown() const { return getOS() == Triple::UnknownOS; }
529
530  bool isGNUEnvironment() const {
531    EnvironmentType Env = getEnvironment();
532    return Env == Triple::GNU || Env == Triple::GNUABIN32 ||
533           Env == Triple::GNUABI64 || Env == Triple::GNUEABI ||
534           Env == Triple::GNUEABIHF || Env == Triple::GNUX32;
535  }
536
537  bool isOSContiki() const {
538    return getOS() == Triple::Contiki;
539  }
540
541  /// Tests whether the OS is Haiku.
542  bool isOSHaiku() const {
543    return getOS() == Triple::Haiku;
544  }
545
546  /// Tests whether the OS is Windows.
547  bool isOSWindows() const {
548    return getOS() == Triple::Win32;
549  }
550
551  /// Checks if the environment is MSVC.
552  bool isKnownWindowsMSVCEnvironment() const {
553    return isOSWindows() && getEnvironment() == Triple::MSVC;
554  }
555
556  /// Checks if the environment could be MSVC.
557  bool isWindowsMSVCEnvironment() const {
558    return isKnownWindowsMSVCEnvironment() ||
559           (isOSWindows() && getEnvironment() == Triple::UnknownEnvironment);
560  }
561
562  bool isWindowsCoreCLREnvironment() const {
563    return isOSWindows() && getEnvironment() == Triple::CoreCLR;
564  }
565
566  bool isWindowsItaniumEnvironment() const {
567    return isOSWindows() && getEnvironment() == Triple::Itanium;
568  }
569
570  bool isWindowsCygwinEnvironment() const {
571    return isOSWindows() && getEnvironment() == Triple::Cygnus;
572  }
573
574  bool isWindowsGNUEnvironment() const {
575    return isOSWindows() && getEnvironment() == Triple::GNU;
576  }
577
578  /// Tests for either Cygwin or MinGW OS
579  bool isOSCygMing() const {
580    return isWindowsCygwinEnvironment() || isWindowsGNUEnvironment();
581  }
582
583  /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment.
584  bool isOSMSVCRT() const {
585    return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() ||
586           isWindowsItaniumEnvironment();
587  }
588
589  /// Tests whether the OS is NaCl (Native Client)
590  bool isOSNaCl() const {
591    return getOS() == Triple::NaCl;
592  }
593
594  /// Tests whether the OS is Linux.
595  bool isOSLinux() const {
596    return getOS() == Triple::Linux;
597  }
598
599  /// Tests whether the OS is kFreeBSD.
600  bool isOSKFreeBSD() const {
601    return getOS() == Triple::KFreeBSD;
602  }
603
604  /// Tests whether the OS is Hurd.
605  bool isOSHurd() const {
606    return getOS() == Triple::Hurd;
607  }
608
609  /// Tests whether the OS is WASI.
610  bool isOSWASI() const {
611    return getOS() == Triple::WASI;
612  }
613
614  /// Tests whether the OS is Emscripten.
615  bool isOSEmscripten() const {
616    return getOS() == Triple::Emscripten;
617  }
618
619  /// Tests whether the OS uses glibc.
620  bool isOSGlibc() const {
621    return (getOS() == Triple::Linux || getOS() == Triple::KFreeBSD ||
622            getOS() == Triple::Hurd) &&
623           !isAndroid();
624  }
625
626  /// Tests whether the OS is AIX.
627  bool isOSAIX() const {
628    return getOS() == Triple::AIX;
629  }
630
631  /// Tests whether the OS uses the ELF binary format.
632  bool isOSBinFormatELF() const {
633    return getObjectFormat() == Triple::ELF;
634  }
635
636  /// Tests whether the OS uses the COFF binary format.
637  bool isOSBinFormatCOFF() const {
638    return getObjectFormat() == Triple::COFF;
639  }
640
641  /// Tests whether the OS uses the GOFF binary format.
642  bool isOSBinFormatGOFF() const { return getObjectFormat() == Triple::GOFF; }
643
644  /// Tests whether the environment is MachO.
645  bool isOSBinFormatMachO() const {
646    return getObjectFormat() == Triple::MachO;
647  }
648
649  /// Tests whether the OS uses the Wasm binary format.
650  bool isOSBinFormatWasm() const {
651    return getObjectFormat() == Triple::Wasm;
652  }
653
654  /// Tests whether the OS uses the XCOFF binary format.
655  bool isOSBinFormatXCOFF() const {
656    return getObjectFormat() == Triple::XCOFF;
657  }
658
659  /// Tests whether the target is the PS4 CPU
660  bool isPS4CPU() const {
661    return getArch() == Triple::x86_64 &&
662           getVendor() == Triple::SCEI &&
663           getOS() == Triple::PS4;
664  }
665
666  /// Tests whether the target is the PS4 platform
667  bool isPS4() const {
668    return getVendor() == Triple::SCEI &&
669           getOS() == Triple::PS4;
670  }
671
672  /// Tests whether the target is Android
673  bool isAndroid() const { return getEnvironment() == Triple::Android; }
674
675  bool isAndroidVersionLT(unsigned Major) const {
676    assert(isAndroid() && "Not an Android triple!");
677
678    unsigned Env[3];
679    getEnvironmentVersion(Env[0], Env[1], Env[2]);
680
681    // 64-bit targets did not exist before API level 21 (Lollipop).
682    if (isArch64Bit() && Env[0] < 21)
683      Env[0] = 21;
684
685    return Env[0] < Major;
686  }
687
688  /// Tests whether the environment is musl-libc
689  bool isMusl() const {
690    return getEnvironment() == Triple::Musl ||
691           getEnvironment() == Triple::MuslEABI ||
692           getEnvironment() == Triple::MuslEABIHF ||
693           getEnvironment() == Triple::MuslX32;
694  }
695
696  /// Tests whether the target is SPIR (32- or 64-bit).
697  bool isSPIR() const {
698    return getArch() == Triple::spir || getArch() == Triple::spir64;
699  }
700
701  /// Tests whether the target is NVPTX (32- or 64-bit).
702  bool isNVPTX() const {
703    return getArch() == Triple::nvptx || getArch() == Triple::nvptx64;
704  }
705
706  /// Tests whether the target is AMDGCN
707  bool isAMDGCN() const { return getArch() == Triple::amdgcn; }
708
709  bool isAMDGPU() const {
710    return getArch() == Triple::r600 || getArch() == Triple::amdgcn;
711  }
712
713  /// Tests whether the target is Thumb (little and big endian).
714  bool isThumb() const {
715    return getArch() == Triple::thumb || getArch() == Triple::thumbeb;
716  }
717
718  /// Tests whether the target is ARM (little and big endian).
719  bool isARM() const {
720    return getArch() == Triple::arm || getArch() == Triple::armeb;
721  }
722
723  /// Tests whether the target is AArch64 (little and big endian).
724  bool isAArch64() const {
725    return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be ||
726           getArch() == Triple::aarch64_32;
727  }
728
729  /// Tests whether the target is AArch64 and pointers are the size specified by
730  /// \p PointerWidth.
731  bool isAArch64(int PointerWidth) const {
732    assert(PointerWidth == 64 || PointerWidth == 32);
733    if (!isAArch64())
734      return false;
735    return getArch() == Triple::aarch64_32 ||
736                   getEnvironment() == Triple::GNUILP32
737               ? PointerWidth == 32
738               : PointerWidth == 64;
739  }
740
741  /// Tests whether the target is MIPS 32-bit (little and big endian).
742  bool isMIPS32() const {
743    return getArch() == Triple::mips || getArch() == Triple::mipsel;
744  }
745
746  /// Tests whether the target is MIPS 64-bit (little and big endian).
747  bool isMIPS64() const {
748    return getArch() == Triple::mips64 || getArch() == Triple::mips64el;
749  }
750
751  /// Tests whether the target is MIPS (little and big endian, 32- or 64-bit).
752  bool isMIPS() const {
753    return isMIPS32() || isMIPS64();
754  }
755
756  /// Tests whether the target is PowerPC (32- or 64-bit LE or BE).
757  bool isPPC() const {
758    return getArch() == Triple::ppc || getArch() == Triple::ppc64 ||
759           getArch() == Triple::ppcle || getArch() == Triple::ppc64le;
760  }
761
762  /// Tests whether the target is 32-bit PowerPC (little and big endian).
763  bool isPPC32() const {
764    return getArch() == Triple::ppc || getArch() == Triple::ppcle;
765  }
766
767  /// Tests whether the target is 64-bit PowerPC (little and big endian).
768  bool isPPC64() const {
769    return getArch() == Triple::ppc64 || getArch() == Triple::ppc64le;
770  }
771
772  /// Tests whether the target is RISC-V (32- and 64-bit).
773  bool isRISCV() const {
774    return getArch() == Triple::riscv32 || getArch() == Triple::riscv64;
775  }
776
777  /// Tests whether the target is SystemZ.
778  bool isSystemZ() const {
779    return getArch() == Triple::systemz;
780  }
781
782  /// Tests whether the target is x86 (32- or 64-bit).
783  bool isX86() const {
784    return getArch() == Triple::x86 || getArch() == Triple::x86_64;
785  }
786
787  /// Tests whether the target is VE
788  bool isVE() const {
789    return getArch() == Triple::ve;
790  }
791
792  /// Tests whether the target is wasm (32- and 64-bit).
793  bool isWasm() const {
794    return getArch() == Triple::wasm32 || getArch() == Triple::wasm64;
795  }
796
797  // Tests whether the target is CSKY
798  bool isCSKY() const {
799    return getArch() == Triple::csky;
800  }
801
802  /// Tests whether the target is the Apple "arm64e" AArch64 subarch.
803  bool isArm64e() const {
804    return getArch() == Triple::aarch64 &&
805           getSubArch() == Triple::AArch64SubArch_arm64e;
806  }
807
808  /// Tests whether the target supports comdat
809  bool supportsCOMDAT() const {
810    return !(isOSBinFormatMachO() || isOSBinFormatXCOFF());
811  }
812
813  /// Tests whether the target uses emulated TLS as default.
814  bool hasDefaultEmulatedTLS() const {
815    return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment();
816  }
817
818  /// Tests whether the target uses -data-sections as default.
819  bool hasDefaultDataSections() const {
820    return isOSBinFormatXCOFF() || isWasm();
821  }
822
823  /// Tests if the environment supports dllimport/export annotations.
824  bool hasDLLImportExport() const { return isOSWindows() || isPS4CPU(); }
825
826  /// @}
827  /// @name Mutators
828  /// @{
829
830  /// setArch - Set the architecture (first) component of the triple
831  /// to a known type.
832  void setArch(ArchType Kind);
833
834  /// setVendor - Set the vendor (second) component of the triple to a
835  /// known type.
836  void setVendor(VendorType Kind);
837
838  /// setOS - Set the operating system (third) component of the triple
839  /// to a known type.
840  void setOS(OSType Kind);
841
842  /// setEnvironment - Set the environment (fourth) component of the triple
843  /// to a known type.
844  void setEnvironment(EnvironmentType Kind);
845
846  /// setObjectFormat - Set the object file format
847  void setObjectFormat(ObjectFormatType Kind);
848
849  /// setTriple - Set all components to the new triple \p Str.
850  void setTriple(const Twine &Str);
851
852  /// setArchName - Set the architecture (first) component of the
853  /// triple by name.
854  void setArchName(StringRef Str);
855
856  /// setVendorName - Set the vendor (second) component of the triple
857  /// by name.
858  void setVendorName(StringRef Str);
859
860  /// setOSName - Set the operating system (third) component of the
861  /// triple by name.
862  void setOSName(StringRef Str);
863
864  /// setEnvironmentName - Set the optional environment (fourth)
865  /// component of the triple by name.
866  void setEnvironmentName(StringRef Str);
867
868  /// setOSAndEnvironmentName - Set the operating system and optional
869  /// environment components with a single string.
870  void setOSAndEnvironmentName(StringRef Str);
871
872  /// @}
873  /// @name Helpers to build variants of a particular triple.
874  /// @{
875
876  /// Form a triple with a 32-bit variant of the current architecture.
877  ///
878  /// This can be used to move across "families" of architectures where useful.
879  ///
880  /// \returns A new triple with a 32-bit architecture or an unknown
881  ///          architecture if no such variant can be found.
882  llvm::Triple get32BitArchVariant() const;
883
884  /// Form a triple with a 64-bit variant of the current architecture.
885  ///
886  /// This can be used to move across "families" of architectures where useful.
887  ///
888  /// \returns A new triple with a 64-bit architecture or an unknown
889  ///          architecture if no such variant can be found.
890  llvm::Triple get64BitArchVariant() const;
891
892  /// Form a triple with a big endian variant of the current architecture.
893  ///
894  /// This can be used to move across "families" of architectures where useful.
895  ///
896  /// \returns A new triple with a big endian architecture or an unknown
897  ///          architecture if no such variant can be found.
898  llvm::Triple getBigEndianArchVariant() const;
899
900  /// Form a triple with a little endian variant of the current architecture.
901  ///
902  /// This can be used to move across "families" of architectures where useful.
903  ///
904  /// \returns A new triple with a little endian architecture or an unknown
905  ///          architecture if no such variant can be found.
906  llvm::Triple getLittleEndianArchVariant() const;
907
908  /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
909  ///
910  /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty
911  /// string then the triple's arch name is used.
912  StringRef getARMCPUForArch(StringRef Arch = StringRef()) const;
913
914  /// Tests whether the target triple is little endian.
915  ///
916  /// \returns true if the triple is little endian, false otherwise.
917  bool isLittleEndian() const;
918
919  /// Test whether target triples are compatible.
920  bool isCompatibleWith(const Triple &Other) const;
921
922  /// Merge target triples.
923  std::string merge(const Triple &Other) const;
924
925  /// Some platforms have different minimum supported OS versions that
926  /// varies by the architecture specified in the triple. This function
927  /// returns the minimum supported OS version for this triple if one an exists,
928  /// or an invalid version tuple if this triple doesn't have one.
929  VersionTuple getMinimumSupportedOSVersion() const;
930
931  /// @}
932  /// @name Static helpers for IDs.
933  /// @{
934
935  /// getArchTypeName - Get the canonical name for the \p Kind architecture.
936  static StringRef getArchTypeName(ArchType Kind);
937
938  /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind
939  /// architecture. This is the prefix used by the architecture specific
940  /// builtins, and is suitable for passing to \see
941  /// Intrinsic::getIntrinsicForGCCBuiltin().
942  ///
943  /// \return - The architecture prefix, or 0 if none is defined.
944  static StringRef getArchTypePrefix(ArchType Kind);
945
946  /// getVendorTypeName - Get the canonical name for the \p Kind vendor.
947  static StringRef getVendorTypeName(VendorType Kind);
948
949  /// getOSTypeName - Get the canonical name for the \p Kind operating system.
950  static StringRef getOSTypeName(OSType Kind);
951
952  /// getEnvironmentTypeName - Get the canonical name for the \p Kind
953  /// environment.
954  static StringRef getEnvironmentTypeName(EnvironmentType Kind);
955
956  /// @}
957  /// @name Static helpers for converting alternate architecture names.
958  /// @{
959
960  /// getArchTypeForLLVMName - The canonical type for the given LLVM
961  /// architecture name (e.g., "x86").
962  static ArchType getArchTypeForLLVMName(StringRef Str);
963
964  /// @}
965
966  /// Returns a canonicalized OS version number for the specified OS.
967  static VersionTuple getCanonicalVersionForOS(OSType OSKind,
968                                               const VersionTuple &Version);
969};
970
971} // End llvm namespace
972
973
974#endif
975