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

source code of include/llvm-17/llvm/TargetParser/Triple.h