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