1//===--- Triple.cpp - Target triple helper class --------------------------===//
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#include "llvm/TargetParser/Triple.h"
10#include "llvm/ADT/DenseMap.h"
11#include "llvm/ADT/StringExtras.h"
12#include "llvm/ADT/StringSwitch.h"
13#include "llvm/Support/CodeGen.h"
14#include "llvm/Support/ErrorHandling.h"
15#include "llvm/Support/SwapByteOrder.h"
16#include "llvm/Support/VersionTuple.h"
17#include "llvm/TargetParser/AMDGPUTargetParser.h"
18#include "llvm/TargetParser/ARMTargetParser.h"
19#include "llvm/TargetParser/ARMTargetParserCommon.h"
20#include "llvm/TargetParser/Host.h"
21#include "llvm/TargetParser/TargetParser.h"
22#include <cassert>
23#include <cstring>
24using namespace llvm;
25
26bool Triple::operator==(const Triple &Other) const {
27 return Arch == Other.Arch && SubArch == Other.SubArch &&
28 Vendor == Other.Vendor && OS == Other.OS &&
29 Environment == Other.Environment && ObjectFormat == Other.ObjectFormat;
30}
31
32bool Triple::operator<(const Triple &Other) const {
33 return std::tie(args: Arch, args: SubArch, args: Vendor, args: OS, args: Environment, args: ObjectFormat, args: Data) <
34 std::tie(args: Other.Arch, args: Other.SubArch, args: Other.Vendor, args: Other.OS,
35 args: Other.Environment, args: Other.ObjectFormat, args: Other.Data);
36}
37
38StringRef Triple::getArchTypeName(ArchType Kind) {
39 switch (Kind) {
40 case UnknownArch:
41 return "unknown";
42
43 case aarch64:
44 return "aarch64";
45 case aarch64_32:
46 return "aarch64_32";
47 case aarch64_be:
48 return "aarch64_be";
49 case amdgpu:
50 return "amdgpu";
51 case amdil64:
52 return "amdil64";
53 case amdil:
54 return "amdil";
55 case arc:
56 return "arc";
57 case arm:
58 return "arm";
59 case armeb:
60 return "armeb";
61 case avr:
62 return "avr";
63 case bpfeb:
64 return "bpfeb";
65 case bpfel:
66 return "bpfel";
67 case csky:
68 return "csky";
69 case dxil:
70 return "dxil";
71 case hexagon:
72 return "hexagon";
73 case hsail64:
74 return "hsail64";
75 case hsail:
76 return "hsail";
77 case kalimba:
78 return "kalimba";
79 case lanai:
80 return "lanai";
81 case loongarch32:
82 return "loongarch32";
83 case loongarch64:
84 return "loongarch64";
85 case m68k:
86 return "m68k";
87 case mips64:
88 return "mips64";
89 case mips64el:
90 return "mips64el";
91 case mips:
92 return "mips";
93 case mipsel:
94 return "mipsel";
95 case msp430:
96 return "msp430";
97 case nvptx64:
98 return "nvptx64";
99 case nvptx:
100 return "nvptx";
101 case ppc64:
102 return "powerpc64";
103 case ppc64le:
104 return "powerpc64le";
105 case ppc:
106 return "powerpc";
107 case ppcle:
108 return "powerpcle";
109 case r600:
110 return "r600";
111 case renderscript32:
112 return "renderscript32";
113 case renderscript64:
114 return "renderscript64";
115 case riscv32:
116 return "riscv32";
117 case riscv64:
118 return "riscv64";
119 case riscv32be:
120 return "riscv32be";
121 case riscv64be:
122 return "riscv64be";
123 case shave:
124 return "shave";
125 case sparc:
126 return "sparc";
127 case sparcel:
128 return "sparcel";
129 case sparcv9:
130 return "sparcv9";
131 case spir64:
132 return "spir64";
133 case spir:
134 return "spir";
135 case spirv:
136 return "spirv";
137 case spirv32:
138 return "spirv32";
139 case spirv64:
140 return "spirv64";
141 case systemz:
142 return "s390x";
143 case tce:
144 return "tce";
145 case tcele:
146 return "tcele";
147 case tcele64:
148 return "tcele64";
149 case thumb:
150 return "thumb";
151 case thumbeb:
152 return "thumbeb";
153 case ve:
154 return "ve";
155 case wasm32:
156 return "wasm32";
157 case wasm64:
158 return "wasm64";
159 case x86:
160 return "i386";
161 case x86_64:
162 return "x86_64";
163 case xcore:
164 return "xcore";
165 case xtensa:
166 return "xtensa";
167 }
168
169 llvm_unreachable("Invalid ArchType!");
170}
171
172StringRef Triple::getArchName(ArchType Kind, SubArchType SubArch) {
173 switch (Kind) {
174 case Triple::mips:
175 if (SubArch == MipsSubArch_r6)
176 return "mipsisa32r6";
177 break;
178 case Triple::mipsel:
179 if (SubArch == MipsSubArch_r6)
180 return "mipsisa32r6el";
181 break;
182 case Triple::mips64:
183 if (SubArch == MipsSubArch_r6)
184 return "mipsisa64r6";
185 break;
186 case Triple::mips64el:
187 if (SubArch == MipsSubArch_r6)
188 return "mipsisa64r6el";
189 break;
190 case Triple::aarch64:
191 if (SubArch == AArch64SubArch_arm64ec)
192 return "arm64ec";
193 if (SubArch == AArch64SubArch_arm64e)
194 return "arm64e";
195 if (SubArch == AArch64SubArch_lfi)
196 return "aarch64_lfi";
197 break;
198 case Triple::x86_64:
199 if (SubArch == X86_64SubArch_lfi)
200 return "x86_64_lfi";
201 break;
202 case Triple::spirv:
203 switch (SubArch) {
204 case Triple::SPIRVSubArch_v10:
205 return "spirv1.0";
206 case Triple::SPIRVSubArch_v11:
207 return "spirv1.1";
208 case Triple::SPIRVSubArch_v12:
209 return "spirv1.2";
210 case Triple::SPIRVSubArch_v13:
211 return "spirv1.3";
212 case Triple::SPIRVSubArch_v14:
213 return "spirv1.4";
214 case Triple::SPIRVSubArch_v15:
215 return "spirv1.5";
216 case Triple::SPIRVSubArch_v16:
217 return "spirv1.6";
218 default:
219 break;
220 }
221 break;
222 case Triple::dxil:
223 switch (SubArch) {
224 case Triple::NoSubArch:
225 case Triple::DXILSubArch_v1_0:
226 return "dxilv1.0";
227 case Triple::DXILSubArch_v1_1:
228 return "dxilv1.1";
229 case Triple::DXILSubArch_v1_2:
230 return "dxilv1.2";
231 case Triple::DXILSubArch_v1_3:
232 return "dxilv1.3";
233 case Triple::DXILSubArch_v1_4:
234 return "dxilv1.4";
235 case Triple::DXILSubArch_v1_5:
236 return "dxilv1.5";
237 case Triple::DXILSubArch_v1_6:
238 return "dxilv1.6";
239 case Triple::DXILSubArch_v1_7:
240 return "dxilv1.7";
241 case Triple::DXILSubArch_v1_8:
242 return "dxilv1.8";
243 case Triple::DXILSubArch_v1_9:
244 return "dxilv1.9";
245 default:
246 break;
247 }
248 break;
249 case Triple::amdgpu: {
250 if (SubArch < Triple::FirstAMDGPUSubArch ||
251 SubArch > Triple::LastAMDGPUSubArch)
252 break;
253
254 static const StringLiteral AMDGPUSubArchNames[Triple::LastAMDGPUSubArch -
255 Triple::FirstAMDGPUSubArch +
256 1] = {
257 "amdgpu6", "amdgpu6.00", "amdgpu6.01", "amdgpu6.02",
258
259 "amdgpu7", "amdgpu7.00", "amdgpu7.01", "amdgpu7.02",
260 "amdgpu7.03", "amdgpu7.04", "amdgpu7.05",
261
262 "amdgpu8", "amdgpu8.01", "amdgpu8.02", "amdgpu8.03",
263 "amdgpu8.05",
264
265 "amdgpu8.10",
266
267 "amdgpu9", "amdgpu9.00", "amdgpu9.02", "amdgpu9.04",
268 "amdgpu9.06", "amdgpu9.09", "amdgpu9.0c",
269
270 "amdgpu9.08", "amdgpu9.0a",
271
272 "amdgpu9.4", "amdgpu9.42", "amdgpu9.50",
273
274 "amdgpu10.1", "amdgpu10.10", "amdgpu10.11", "amdgpu10.12",
275 "amdgpu10.13",
276
277 "amdgpu10.3", "amdgpu10.30", "amdgpu10.31", "amdgpu10.32",
278 "amdgpu10.33", "amdgpu10.34", "amdgpu10.35", "amdgpu10.36",
279
280 "amdgpu11", "amdgpu11.00", "amdgpu11.01", "amdgpu11.02",
281 "amdgpu11.03", "amdgpu11.50", "amdgpu11.51", "amdgpu11.52",
282 "amdgpu11.53", "amdgpu11.54",
283
284 "amdgpu11.7", "amdgpu11.70", "amdgpu11.71", "amdgpu11.72",
285
286 "amdgpu12", "amdgpu12.00", "amdgpu12.01",
287
288 "amdgpu12.5", "amdgpu12.50", "amdgpu12.51",
289
290 "amdgpu13", "amdgpu13.10"};
291
292 return AMDGPUSubArchNames[SubArch - Triple::FirstAMDGPUSubArch];
293 }
294 default:
295 break;
296 }
297 return getArchTypeName(Kind);
298}
299
300StringRef Triple::getArchTypePrefix(ArchType Kind) {
301 switch (Kind) {
302 default:
303 return StringRef();
304
305 case aarch64:
306 case aarch64_be:
307 case aarch64_32:
308 return "aarch64";
309
310 case arc:
311 return "arc";
312
313 case arm:
314 case armeb:
315 case thumb:
316 case thumbeb:
317 return "arm";
318
319 case avr:
320 return "avr";
321
322 case ppc64:
323 case ppc64le:
324 case ppc:
325 case ppcle:
326 return "ppc";
327
328 case m68k:
329 return "m68k";
330
331 case mips:
332 case mipsel:
333 case mips64:
334 case mips64el:
335 return "mips";
336
337 case hexagon:
338 return "hexagon";
339
340 // Intrinsics use amdgcn prefix.
341 case amdgpu:
342 return "amdgcn";
343 case r600:
344 return "r600";
345
346 case bpfel:
347 case bpfeb:
348 return "bpf";
349
350 case sparcv9:
351 case sparcel:
352 case sparc:
353 return "sparc";
354
355 case systemz:
356 return "s390";
357
358 case x86:
359 case x86_64:
360 return "x86";
361
362 case xcore:
363 return "xcore";
364
365 // NVPTX intrinsics are namespaced under nvvm.
366 case nvptx:
367 return "nvvm";
368 case nvptx64:
369 return "nvvm";
370
371 case amdil:
372 case amdil64:
373 return "amdil";
374
375 case hsail:
376 case hsail64:
377 return "hsail";
378
379 case spir:
380 case spir64:
381 return "spir";
382
383 case spirv:
384 case spirv32:
385 case spirv64:
386 return "spv";
387
388 case kalimba:
389 return "kalimba";
390 case lanai:
391 return "lanai";
392 case shave:
393 return "shave";
394 case wasm32:
395 case wasm64:
396 return "wasm";
397
398 case riscv32:
399 case riscv64:
400 case riscv32be:
401 case riscv64be:
402 return "riscv";
403
404 case ve:
405 return "ve";
406 case csky:
407 return "csky";
408
409 case loongarch32:
410 case loongarch64:
411 return "loongarch";
412
413 case dxil:
414 return "dx";
415
416 case xtensa:
417 return "xtensa";
418 }
419}
420
421StringRef Triple::getVendorTypeName(VendorType Kind) {
422 switch (Kind) {
423 case UnknownVendor:
424 return "unknown";
425#define TRIPLE_VENDOR(Enum, Name) \
426 case Enum: \
427 return Name;
428#include "llvm/TargetParser/TripleName.def"
429 }
430
431 llvm_unreachable("Invalid VendorType!");
432}
433
434StringRef Triple::getOSTypeName(OSType Kind) {
435 switch (Kind) {
436 case UnknownOS:
437 return "unknown";
438#define TRIPLE_OS(Enum, Name) \
439 case Enum: \
440 return Name;
441#include "llvm/TargetParser/TripleName.def"
442 }
443
444 llvm_unreachable("Invalid OSType");
445}
446
447StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
448 switch (Kind) {
449 case UnknownEnvironment:
450 return "unknown";
451#define TRIPLE_ENV(Enum, Name) \
452 case Enum: \
453 return Name;
454#include "llvm/TargetParser/TripleName.def"
455 }
456
457 llvm_unreachable("Invalid EnvironmentType!");
458}
459
460StringRef Triple::getObjectFormatTypeName(ObjectFormatType Kind) {
461 switch (Kind) {
462 case UnknownObjectFormat:
463 return "";
464 case COFF:
465 return "coff";
466 case ELF:
467 return "elf";
468 case GOFF:
469 return "goff";
470 case MachO:
471 return "macho";
472 case Wasm:
473 return "wasm";
474 case XCOFF:
475 return "xcoff";
476 case DXContainer:
477 return "dxcontainer";
478 case SPIRV:
479 return "spirv";
480 }
481 llvm_unreachable("unknown object format type");
482}
483
484static Triple::ArchType parseBPFArch(StringRef ArchName) {
485 if (ArchName == "bpf") {
486 if (sys::IsLittleEndianHost)
487 return Triple::bpfel;
488 else
489 return Triple::bpfeb;
490 } else if (ArchName == "bpf_be" || ArchName == "bpfeb") {
491 return Triple::bpfeb;
492 } else if (ArchName == "bpf_le" || ArchName == "bpfel") {
493 return Triple::bpfel;
494 } else {
495 return Triple::UnknownArch;
496 }
497}
498
499Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
500 Triple::ArchType BPFArch(parseBPFArch(ArchName: Name));
501 return StringSwitch<Triple::ArchType>(Name)
502 .Case(S: "aarch64", Value: aarch64)
503 .Case(S: "aarch64_be", Value: aarch64_be)
504 .Case(S: "aarch64_32", Value: aarch64_32)
505 .Case(S: "arc", Value: arc)
506 .Case(S: "arm64", Value: aarch64) // "arm64" is an alias for "aarch64"
507 .Case(S: "arm64_32", Value: aarch64_32)
508 .Case(S: "arm", Value: arm)
509 .Case(S: "armeb", Value: armeb)
510 .Case(S: "avr", Value: avr)
511 .StartsWith(S: "bpf", Value: BPFArch)
512 .Case(S: "m68k", Value: m68k)
513 .Case(S: "mips", Value: mips)
514 .Case(S: "mipsel", Value: mipsel)
515 .Case(S: "mips64", Value: mips64)
516 .Case(S: "mips64el", Value: mips64el)
517 .Case(S: "msp430", Value: msp430)
518 .Case(S: "ppc64", Value: ppc64)
519 .Case(S: "ppc32", Value: ppc)
520 .Case(S: "ppc", Value: ppc)
521 .Case(S: "ppc32le", Value: ppcle)
522 .Case(S: "ppcle", Value: ppcle)
523 .Case(S: "ppc64le", Value: ppc64le)
524 .Case(S: "amdgpu", Value: amdgpu)
525 .Case(S: "amdgcn", Value: amdgpu) // Legacy name
526 .Case(S: "r600", Value: r600)
527 .Case(S: "riscv32", Value: riscv32)
528 .Case(S: "riscv64", Value: riscv64)
529 .Case(S: "riscv32be", Value: riscv32be)
530 .Case(S: "riscv64be", Value: riscv64be)
531 .Case(S: "hexagon", Value: hexagon)
532 .Case(S: "sparc", Value: sparc)
533 .Case(S: "sparcel", Value: sparcel)
534 .Case(S: "sparcv9", Value: sparcv9)
535 .Case(S: "s390x", Value: systemz)
536 .Case(S: "systemz", Value: systemz)
537 .Case(S: "tce", Value: tce)
538 .Case(S: "tcele", Value: tcele)
539 .Case(S: "tcele64", Value: tcele64)
540 .Case(S: "thumb", Value: thumb)
541 .Case(S: "thumbeb", Value: thumbeb)
542 .Case(S: "x86", Value: x86)
543 .Case(S: "i386", Value: x86)
544 .Case(S: "x86-64", Value: x86_64)
545 .Case(S: "xcore", Value: xcore)
546 .Case(S: "nvptx", Value: nvptx)
547 .Case(S: "nvptx64", Value: nvptx64)
548 .Case(S: "amdil", Value: amdil)
549 .Case(S: "amdil64", Value: amdil64)
550 .Case(S: "hsail", Value: hsail)
551 .Case(S: "hsail64", Value: hsail64)
552 .Case(S: "spir", Value: spir)
553 .Case(S: "spir64", Value: spir64)
554 .Case(S: "spirv", Value: spirv)
555 .Case(S: "spirv32", Value: spirv32)
556 .Case(S: "spirv64", Value: spirv64)
557 .Case(S: "kalimba", Value: kalimba)
558 .Case(S: "lanai", Value: lanai)
559 .Case(S: "shave", Value: shave)
560 .Case(S: "wasm32", Value: wasm32)
561 .Case(S: "wasm64", Value: wasm64)
562 .Case(S: "renderscript32", Value: renderscript32)
563 .Case(S: "renderscript64", Value: renderscript64)
564 .Case(S: "ve", Value: ve)
565 .Case(S: "csky", Value: csky)
566 .Case(S: "loongarch32", Value: loongarch32)
567 .Case(S: "loongarch64", Value: loongarch64)
568 .Case(S: "dxil", Value: dxil)
569 .Case(S: "xtensa", Value: xtensa)
570 .Default(Value: UnknownArch);
571}
572
573static Triple::ArchType parseARMArch(StringRef ArchName) {
574 ARM::ISAKind ISA = ARM::parseArchISA(Arch: ArchName);
575 ARM::EndianKind ENDIAN = ARM::parseArchEndian(Arch: ArchName);
576
577 Triple::ArchType arch = Triple::UnknownArch;
578 switch (ENDIAN) {
579 case ARM::EndianKind::LITTLE: {
580 switch (ISA) {
581 case ARM::ISAKind::ARM:
582 arch = Triple::arm;
583 break;
584 case ARM::ISAKind::THUMB:
585 arch = Triple::thumb;
586 break;
587 case ARM::ISAKind::AARCH64:
588 arch = Triple::aarch64;
589 break;
590 case ARM::ISAKind::INVALID:
591 break;
592 }
593 break;
594 }
595 case ARM::EndianKind::BIG: {
596 switch (ISA) {
597 case ARM::ISAKind::ARM:
598 arch = Triple::armeb;
599 break;
600 case ARM::ISAKind::THUMB:
601 arch = Triple::thumbeb;
602 break;
603 case ARM::ISAKind::AARCH64:
604 arch = Triple::aarch64_be;
605 break;
606 case ARM::ISAKind::INVALID:
607 break;
608 }
609 break;
610 }
611 case ARM::EndianKind::INVALID: {
612 break;
613 }
614 }
615
616 ArchName = ARM::getCanonicalArchName(Arch: ArchName);
617 if (ArchName.empty())
618 return Triple::UnknownArch;
619
620 // Thumb only exists in v4+
621 if (ISA == ARM::ISAKind::THUMB &&
622 (ArchName.starts_with(Prefix: "v2") || ArchName.starts_with(Prefix: "v3")))
623 return Triple::UnknownArch;
624
625 // Thumb only for v6m
626 ARM::ProfileKind Profile = ARM::parseArchProfile(Arch: ArchName);
627 unsigned Version = ARM::parseArchVersion(Arch: ArchName);
628 if (Profile == ARM::ProfileKind::M && Version == 6) {
629 if (ENDIAN == ARM::EndianKind::BIG)
630 return Triple::thumbeb;
631 else
632 return Triple::thumb;
633 }
634
635 return arch;
636}
637
638Triple::ArchType Triple::parseArch(StringRef ArchName) {
639 auto AT =
640 StringSwitch<Triple::ArchType>(ArchName)
641 .Cases(CaseStrings: {"i386", "i486", "i586", "i686"}, Value: Triple::x86)
642 // FIXME: Do we need to support these?
643 .Cases(CaseStrings: {"i786", "i886", "i986"}, Value: Triple::x86)
644 .Cases(CaseStrings: {"amd64", "x86_64", "x86_64h", "x86_64_lfi"}, Value: Triple::x86_64)
645 .Cases(CaseStrings: {"powerpc", "powerpcspe", "ppc", "ppc32"}, Value: Triple::ppc)
646 .Cases(CaseStrings: {"powerpcle", "ppcle", "ppc32le"}, Value: Triple::ppcle)
647 .Cases(CaseStrings: {"powerpc64", "ppu", "ppc64"}, Value: Triple::ppc64)
648 .Cases(CaseStrings: {"powerpc64le", "ppc64le"}, Value: Triple::ppc64le)
649 .Case(S: "xscale", Value: Triple::arm)
650 .Case(S: "xscaleeb", Value: Triple::armeb)
651 .Case(S: "aarch64", Value: Triple::aarch64)
652 .Case(S: "aarch64_be", Value: Triple::aarch64_be)
653 .Case(S: "aarch64_32", Value: Triple::aarch64_32)
654 .Case(S: "aarch64_lfi", Value: Triple::aarch64)
655 .Case(S: "arc", Value: Triple::arc)
656 .Case(S: "arm64", Value: Triple::aarch64)
657 .Case(S: "arm64_32", Value: Triple::aarch64_32)
658 .Case(S: "arm64e", Value: Triple::aarch64)
659 .Case(S: "arm64ec", Value: Triple::aarch64)
660 .Case(S: "arm", Value: Triple::arm)
661 .Case(S: "armeb", Value: Triple::armeb)
662 .Case(S: "thumb", Value: Triple::thumb)
663 .Case(S: "thumbeb", Value: Triple::thumbeb)
664 .Case(S: "avr", Value: Triple::avr)
665 .Case(S: "m68k", Value: Triple::m68k)
666 .Case(S: "msp430", Value: Triple::msp430)
667 .Cases(CaseStrings: {"mips", "mipseb", "mipsallegrex", "mipsisa32r6", "mipsr6"},
668 Value: Triple::mips)
669 .Cases(CaseStrings: {"mipsel", "mipsallegrexel", "mipsisa32r6el", "mipsr6el"},
670 Value: Triple::mipsel)
671 .Cases(CaseStrings: {"mips64", "mips64eb", "mipsn32", "mipsisa64r6", "mips64r6",
672 "mipsn32r6"},
673 Value: Triple::mips64)
674 .Cases(CaseStrings: {"mips64el", "mipsn32el", "mipsisa64r6el", "mips64r6el",
675 "mipsn32r6el"},
676 Value: Triple::mips64el)
677 .StartsWith(S: "amdgpu", Value: Triple::amdgpu)
678 .Case(S: "amdgcn", Value: Triple::amdgpu)
679 .Case(S: "r600", Value: Triple::r600)
680 .Case(S: "riscv32", Value: Triple::riscv32)
681 .Case(S: "riscv64", Value: Triple::riscv64)
682 .Case(S: "riscv32be", Value: Triple::riscv32be)
683 .Case(S: "riscv64be", Value: Triple::riscv64be)
684 .Case(S: "hexagon", Value: Triple::hexagon)
685 .Cases(CaseStrings: {"s390x", "systemz"}, Value: Triple::systemz)
686 .Case(S: "sparc", Value: Triple::sparc)
687 .Case(S: "sparcel", Value: Triple::sparcel)
688 .Cases(CaseStrings: {"sparcv9", "sparc64"}, Value: Triple::sparcv9)
689 .Case(S: "tce", Value: Triple::tce)
690 .Case(S: "tcele", Value: Triple::tcele)
691 .Case(S: "tcele64", Value: Triple::tcele64)
692 .Case(S: "xcore", Value: Triple::xcore)
693 .Case(S: "nvptx", Value: Triple::nvptx)
694 .Case(S: "nvptx64", Value: Triple::nvptx64)
695 .Case(S: "amdil", Value: Triple::amdil)
696 .Case(S: "amdil64", Value: Triple::amdil64)
697 .Case(S: "hsail", Value: Triple::hsail)
698 .Case(S: "hsail64", Value: Triple::hsail64)
699 .Case(S: "spir", Value: Triple::spir)
700 .Case(S: "spir64", Value: Triple::spir64)
701 .Cases(CaseStrings: {"spirv", "spirv1.5", "spirv1.6"}, Value: Triple::spirv)
702 .Cases(CaseStrings: {"spirv32", "spirv32v1.0", "spirv32v1.1", "spirv32v1.2",
703 "spirv32v1.3", "spirv32v1.4", "spirv32v1.5", "spirv32v1.6"},
704 Value: Triple::spirv32)
705 .Cases(CaseStrings: {"spirv64", "spirv64v1.0", "spirv64v1.1", "spirv64v1.2",
706 "spirv64v1.3", "spirv64v1.4", "spirv64v1.5", "spirv64v1.6"},
707 Value: Triple::spirv64)
708 .StartsWith(S: "kalimba", Value: Triple::kalimba)
709 .Case(S: "lanai", Value: Triple::lanai)
710 .Case(S: "renderscript32", Value: Triple::renderscript32)
711 .Case(S: "renderscript64", Value: Triple::renderscript64)
712 .Case(S: "shave", Value: Triple::shave)
713 .Case(S: "ve", Value: Triple::ve)
714 .Case(S: "wasm32", Value: Triple::wasm32)
715 .Case(S: "wasm64", Value: Triple::wasm64)
716 .Case(S: "csky", Value: Triple::csky)
717 .Case(S: "loongarch32", Value: Triple::loongarch32)
718 .Case(S: "loongarch64", Value: Triple::loongarch64)
719 .Cases(CaseStrings: {"dxil", "dxilv1.0", "dxilv1.1", "dxilv1.2", "dxilv1.3",
720 "dxilv1.4", "dxilv1.5", "dxilv1.6", "dxilv1.7", "dxilv1.8",
721 "dxilv1.9"},
722 Value: Triple::dxil)
723 .Case(S: "xtensa", Value: Triple::xtensa)
724 .Default(Value: Triple::UnknownArch);
725
726 // Some architectures require special parsing logic just to compute the
727 // ArchType result.
728 if (AT == Triple::UnknownArch) {
729 if (ArchName.starts_with(Prefix: "arm") || ArchName.starts_with(Prefix: "thumb") ||
730 ArchName.starts_with(Prefix: "aarch64"))
731 return parseARMArch(ArchName);
732 if (ArchName.starts_with(Prefix: "bpf"))
733 return parseBPFArch(ArchName);
734 }
735
736 return AT;
737}
738
739static Triple::VendorType parseVendor(StringRef VendorName) {
740 return StringSwitch<Triple::VendorType>(VendorName)
741#define TRIPLE_VENDOR(Enum, Name) .Case(Name, Triple::Enum)
742#define TRIPLE_VENDOR_ALIAS(Enum, AliasName) .Case(AliasName, Triple::Enum)
743#include "llvm/TargetParser/TripleName.def"
744 .Default(Value: Triple::UnknownVendor);
745}
746
747static Triple::OSType parseOS(StringRef OSName) {
748 return StringSwitch<Triple::OSType>(OSName)
749#define TRIPLE_OS(Enum, Name) .StartsWith(Name, Triple::Enum)
750#define TRIPLE_OS_ALIAS(Enum, AliasName) .StartsWith(AliasName, Triple::Enum)
751#include "llvm/TargetParser/TripleName.def"
752 .Default(Value: Triple::UnknownOS);
753}
754
755static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
756 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
757#define TRIPLE_ENV(Enum, Name) .StartsWith(Name, Triple::Enum)
758#include "llvm/TargetParser/TripleName.def"
759 .Default(Value: Triple::UnknownEnvironment);
760}
761
762static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
763 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
764 // "xcoff" must come before "coff" because of the order-dependendent
765 // pattern matching.
766 .EndsWith(S: "xcoff", Value: Triple::XCOFF)
767 .EndsWith(S: "coff", Value: Triple::COFF)
768 .EndsWith(S: "elf", Value: Triple::ELF)
769 .EndsWith(S: "goff", Value: Triple::GOFF)
770 .EndsWith(S: "macho", Value: Triple::MachO)
771 .EndsWith(S: "wasm", Value: Triple::Wasm)
772 .EndsWith(S: "spirv", Value: Triple::SPIRV)
773 .Default(Value: Triple::UnknownObjectFormat);
774}
775
776Triple::SubArchType Triple::parseSubArch(StringRef SubArchName) {
777 if (SubArchName.starts_with(Prefix: "mips") &&
778 (SubArchName.ends_with(Suffix: "r6el") || SubArchName.ends_with(Suffix: "r6")))
779 return Triple::MipsSubArch_r6;
780
781 if (SubArchName == "powerpcspe")
782 return Triple::PPCSubArch_spe;
783
784 if (SubArchName == "arm64e")
785 return Triple::AArch64SubArch_arm64e;
786
787 if (SubArchName == "arm64ec")
788 return Triple::AArch64SubArch_arm64ec;
789
790 if (SubArchName == "aarch64_lfi")
791 return Triple::AArch64SubArch_lfi;
792
793 if (SubArchName == "x86_64_lfi")
794 return Triple::X86_64SubArch_lfi;
795
796 if (SubArchName.starts_with(Prefix: "spirv"))
797 return StringSwitch<Triple::SubArchType>(SubArchName)
798 .EndsWith(S: "v1.0", Value: Triple::SPIRVSubArch_v10)
799 .EndsWith(S: "v1.1", Value: Triple::SPIRVSubArch_v11)
800 .EndsWith(S: "v1.2", Value: Triple::SPIRVSubArch_v12)
801 .EndsWith(S: "v1.3", Value: Triple::SPIRVSubArch_v13)
802 .EndsWith(S: "v1.4", Value: Triple::SPIRVSubArch_v14)
803 .EndsWith(S: "v1.5", Value: Triple::SPIRVSubArch_v15)
804 .EndsWith(S: "v1.6", Value: Triple::SPIRVSubArch_v16)
805 .Default(Value: Triple::NoSubArch);
806
807 if (SubArchName.starts_with(Prefix: "dxil"))
808 return StringSwitch<Triple::SubArchType>(SubArchName)
809 .EndsWith(S: "v1.0", Value: Triple::DXILSubArch_v1_0)
810 .EndsWith(S: "v1.1", Value: Triple::DXILSubArch_v1_1)
811 .EndsWith(S: "v1.2", Value: Triple::DXILSubArch_v1_2)
812 .EndsWith(S: "v1.3", Value: Triple::DXILSubArch_v1_3)
813 .EndsWith(S: "v1.4", Value: Triple::DXILSubArch_v1_4)
814 .EndsWith(S: "v1.5", Value: Triple::DXILSubArch_v1_5)
815 .EndsWith(S: "v1.6", Value: Triple::DXILSubArch_v1_6)
816 .EndsWith(S: "v1.7", Value: Triple::DXILSubArch_v1_7)
817 .EndsWith(S: "v1.8", Value: Triple::DXILSubArch_v1_8)
818 .EndsWith(S: "v1.9", Value: Triple::DXILSubArch_v1_9)
819 .Default(Value: Triple::NoSubArch);
820
821 if (SubArchName.consume_front(Prefix: "amdgpu")) {
822 return StringSwitch<Triple::SubArchType>(SubArchName)
823 .Case(S: "6", Value: Triple::AMDGPUSubArch6)
824 .Case(S: "6.00", Value: Triple::AMDGPUSubArch600)
825 .Case(S: "6.01", Value: Triple::AMDGPUSubArch601)
826 .Case(S: "6.02", Value: Triple::AMDGPUSubArch602)
827 .Case(S: "7", Value: Triple::AMDGPUSubArch7)
828 .Case(S: "7.00", Value: Triple::AMDGPUSubArch700)
829 .Case(S: "7.01", Value: Triple::AMDGPUSubArch701)
830 .Case(S: "7.02", Value: Triple::AMDGPUSubArch702)
831 .Case(S: "7.03", Value: Triple::AMDGPUSubArch703)
832 .Case(S: "7.04", Value: Triple::AMDGPUSubArch704)
833 .Case(S: "7.05", Value: Triple::AMDGPUSubArch705)
834 .Case(S: "8", Value: Triple::AMDGPUSubArch8)
835 .Case(S: "8.01", Value: Triple::AMDGPUSubArch801)
836 .Case(S: "8.02", Value: Triple::AMDGPUSubArch802)
837 .Case(S: "8.03", Value: Triple::AMDGPUSubArch803)
838 .Case(S: "8.05", Value: Triple::AMDGPUSubArch805)
839 .Case(S: "8.10", Value: Triple::AMDGPUSubArch810)
840 .Case(S: "9", Value: Triple::AMDGPUSubArch9)
841 .Case(S: "9.00", Value: Triple::AMDGPUSubArch900)
842 .Case(S: "9.02", Value: Triple::AMDGPUSubArch902)
843 .Case(S: "9.04", Value: Triple::AMDGPUSubArch904)
844 .Case(S: "9.06", Value: Triple::AMDGPUSubArch906)
845 .Case(S: "9.08", Value: Triple::AMDGPUSubArch908)
846 .Case(S: "9.09", Value: Triple::AMDGPUSubArch909)
847 .Case(S: "9.0a", Value: Triple::AMDGPUSubArch90A)
848 .Case(S: "9.0c", Value: Triple::AMDGPUSubArch90C)
849 .Case(S: "9.4", Value: Triple::AMDGPUSubArch9_4)
850 .Case(S: "9.5", Value: Triple::AMDGPUSubArch9_4)
851 .Case(S: "9.42", Value: Triple::AMDGPUSubArch942)
852 .Case(S: "9.50", Value: Triple::AMDGPUSubArch950)
853 .Case(S: "10", Value: Triple::AMDGPUSubArch10_1)
854 .Case(S: "10.1", Value: Triple::AMDGPUSubArch10_1)
855 .Case(S: "10.10", Value: Triple::AMDGPUSubArch1010)
856 .Case(S: "10.11", Value: Triple::AMDGPUSubArch1011)
857 .Case(S: "10.12", Value: Triple::AMDGPUSubArch1012)
858 .Case(S: "10.13", Value: Triple::AMDGPUSubArch1013)
859 .Case(S: "10.3", Value: Triple::AMDGPUSubArch10_3)
860 .Case(S: "10.30", Value: Triple::AMDGPUSubArch1030)
861 .Case(S: "10.31", Value: Triple::AMDGPUSubArch1031)
862 .Case(S: "10.32", Value: Triple::AMDGPUSubArch1032)
863 .Case(S: "10.33", Value: Triple::AMDGPUSubArch1033)
864 .Case(S: "10.34", Value: Triple::AMDGPUSubArch1034)
865 .Case(S: "10.35", Value: Triple::AMDGPUSubArch1035)
866 .Case(S: "10.36", Value: Triple::AMDGPUSubArch1036)
867 .Case(S: "11", Value: Triple::AMDGPUSubArch11)
868 .Case(S: "11.00", Value: Triple::AMDGPUSubArch1100)
869 .Case(S: "11.01", Value: Triple::AMDGPUSubArch1101)
870 .Case(S: "11.02", Value: Triple::AMDGPUSubArch1102)
871 .Case(S: "11.03", Value: Triple::AMDGPUSubArch1103)
872 .Case(S: "11.50", Value: Triple::AMDGPUSubArch1150)
873 .Case(S: "11.51", Value: Triple::AMDGPUSubArch1151)
874 .Case(S: "11.52", Value: Triple::AMDGPUSubArch1152)
875 .Case(S: "11.53", Value: Triple::AMDGPUSubArch1153)
876 .Case(S: "11.54", Value: Triple::AMDGPUSubArch1154)
877 .Case(S: "11.7", Value: Triple::AMDGPUSubArch11_7)
878 .Case(S: "11.70", Value: Triple::AMDGPUSubArch1170)
879 .Case(S: "11.71", Value: Triple::AMDGPUSubArch1171)
880 .Case(S: "11.72", Value: Triple::AMDGPUSubArch1172)
881 .Case(S: "12", Value: Triple::AMDGPUSubArch12)
882 .Case(S: "12.00", Value: Triple::AMDGPUSubArch1200)
883 .Case(S: "12.01", Value: Triple::AMDGPUSubArch1201)
884 .Case(S: "12.5", Value: Triple::AMDGPUSubArch12_5)
885 .Case(S: "12.50", Value: Triple::AMDGPUSubArch1250)
886 .Case(S: "12.51", Value: Triple::AMDGPUSubArch1251)
887 .Case(S: "13", Value: Triple::AMDGPUSubArch13)
888 .Case(S: "13.10", Value: Triple::AMDGPUSubArch1310)
889 .Default(Value: Triple::NoSubArch);
890 }
891
892 StringRef ARMSubArch = ARM::getCanonicalArchName(Arch: SubArchName);
893
894 // For now, this is the small part. Early return.
895 if (ARMSubArch.empty())
896 return StringSwitch<Triple::SubArchType>(SubArchName)
897 .EndsWith(S: "kalimba3", Value: Triple::KalimbaSubArch_v3)
898 .EndsWith(S: "kalimba4", Value: Triple::KalimbaSubArch_v4)
899 .EndsWith(S: "kalimba5", Value: Triple::KalimbaSubArch_v5)
900 .Default(Value: Triple::NoSubArch);
901
902 // ARM sub arch.
903 switch (ARM::parseArch(Arch: ARMSubArch)) {
904 case ARM::ArchKind::ARMV4:
905 return Triple::NoSubArch;
906 case ARM::ArchKind::ARMV4T:
907 return Triple::ARMSubArch_v4t;
908 case ARM::ArchKind::ARMV5T:
909 return Triple::ARMSubArch_v5;
910 case ARM::ArchKind::ARMV5TE:
911 case ARM::ArchKind::IWMMXT:
912 case ARM::ArchKind::IWMMXT2:
913 case ARM::ArchKind::XSCALE:
914 case ARM::ArchKind::ARMV5TEJ:
915 return Triple::ARMSubArch_v5te;
916 case ARM::ArchKind::ARMV6:
917 return Triple::ARMSubArch_v6;
918 case ARM::ArchKind::ARMV6K:
919 case ARM::ArchKind::ARMV6KZ:
920 return Triple::ARMSubArch_v6k;
921 case ARM::ArchKind::ARMV6T2:
922 return Triple::ARMSubArch_v6t2;
923 case ARM::ArchKind::ARMV6M:
924 return Triple::ARMSubArch_v6m;
925 case ARM::ArchKind::ARMV7A:
926 case ARM::ArchKind::ARMV7R:
927 return Triple::ARMSubArch_v7;
928 case ARM::ArchKind::ARMV7VE:
929 return Triple::ARMSubArch_v7ve;
930 case ARM::ArchKind::ARMV7K:
931 return Triple::ARMSubArch_v7k;
932 case ARM::ArchKind::ARMV7M:
933 return Triple::ARMSubArch_v7m;
934 case ARM::ArchKind::ARMV7S:
935 return Triple::ARMSubArch_v7s;
936 case ARM::ArchKind::ARMV7EM:
937 return Triple::ARMSubArch_v7em;
938 case ARM::ArchKind::ARMV8A:
939 return Triple::ARMSubArch_v8;
940 case ARM::ArchKind::ARMV8_1A:
941 return Triple::ARMSubArch_v8_1a;
942 case ARM::ArchKind::ARMV8_2A:
943 return Triple::ARMSubArch_v8_2a;
944 case ARM::ArchKind::ARMV8_3A:
945 return Triple::ARMSubArch_v8_3a;
946 case ARM::ArchKind::ARMV8_4A:
947 return Triple::ARMSubArch_v8_4a;
948 case ARM::ArchKind::ARMV8_5A:
949 return Triple::ARMSubArch_v8_5a;
950 case ARM::ArchKind::ARMV8_6A:
951 return Triple::ARMSubArch_v8_6a;
952 case ARM::ArchKind::ARMV8_7A:
953 return Triple::ARMSubArch_v8_7a;
954 case ARM::ArchKind::ARMV8_8A:
955 return Triple::ARMSubArch_v8_8a;
956 case ARM::ArchKind::ARMV8_9A:
957 return Triple::ARMSubArch_v8_9a;
958 case ARM::ArchKind::ARMV9A:
959 return Triple::ARMSubArch_v9;
960 case ARM::ArchKind::ARMV9_1A:
961 return Triple::ARMSubArch_v9_1a;
962 case ARM::ArchKind::ARMV9_2A:
963 return Triple::ARMSubArch_v9_2a;
964 case ARM::ArchKind::ARMV9_3A:
965 return Triple::ARMSubArch_v9_3a;
966 case ARM::ArchKind::ARMV9_4A:
967 return Triple::ARMSubArch_v9_4a;
968 case ARM::ArchKind::ARMV9_5A:
969 return Triple::ARMSubArch_v9_5a;
970 case ARM::ArchKind::ARMV9_6A:
971 return Triple::ARMSubArch_v9_6a;
972 case ARM::ArchKind::ARMV9_7A:
973 return Triple::ARMSubArch_v9_7a;
974 case ARM::ArchKind::ARMV8R:
975 return Triple::ARMSubArch_v8r;
976 case ARM::ArchKind::ARMV8MBaseline:
977 return Triple::ARMSubArch_v8m_baseline;
978 case ARM::ArchKind::ARMV8MMainline:
979 return Triple::ARMSubArch_v8m_mainline;
980 case ARM::ArchKind::ARMV8_1MMainline:
981 return Triple::ARMSubArch_v8_1m_mainline;
982 default:
983 return Triple::NoSubArch;
984 }
985}
986
987static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
988 switch (T.getArch()) {
989 case Triple::UnknownArch:
990 case Triple::aarch64:
991 case Triple::aarch64_32:
992 case Triple::arm:
993 case Triple::thumb:
994 case Triple::x86:
995 case Triple::x86_64:
996 switch (T.getOS()) {
997 case Triple::Win32:
998 case Triple::UEFI:
999 return Triple::COFF;
1000 default:
1001 return T.isOSDarwin() ? Triple::MachO : Triple::ELF;
1002 }
1003 case Triple::aarch64_be:
1004 case Triple::amdgpu:
1005 case Triple::amdil64:
1006 case Triple::amdil:
1007 case Triple::arc:
1008 case Triple::armeb:
1009 case Triple::avr:
1010 case Triple::bpfeb:
1011 case Triple::bpfel:
1012 case Triple::csky:
1013 case Triple::hexagon:
1014 case Triple::hsail64:
1015 case Triple::hsail:
1016 case Triple::kalimba:
1017 case Triple::lanai:
1018 case Triple::loongarch32:
1019 case Triple::loongarch64:
1020 case Triple::m68k:
1021 case Triple::mips64:
1022 case Triple::mips64el:
1023 case Triple::mips:
1024 case Triple::msp430:
1025 case Triple::nvptx64:
1026 case Triple::nvptx:
1027 case Triple::ppc64le:
1028 case Triple::ppcle:
1029 case Triple::r600:
1030 case Triple::renderscript32:
1031 case Triple::renderscript64:
1032 case Triple::riscv32:
1033 case Triple::riscv64:
1034 case Triple::riscv32be:
1035 case Triple::riscv64be:
1036 case Triple::shave:
1037 case Triple::sparc:
1038 case Triple::sparcel:
1039 case Triple::sparcv9:
1040 case Triple::spir64:
1041 case Triple::spir:
1042 case Triple::tce:
1043 case Triple::tcele:
1044 case Triple::tcele64:
1045 case Triple::thumbeb:
1046 case Triple::ve:
1047 case Triple::xcore:
1048 case Triple::xtensa:
1049 return Triple::ELF;
1050
1051 case Triple::mipsel:
1052 if (T.isOSWindows())
1053 return Triple::COFF;
1054 return Triple::ELF;
1055
1056 case Triple::ppc64:
1057 case Triple::ppc:
1058 if (T.isOSAIX())
1059 return Triple::XCOFF;
1060 if (T.isOSDarwin())
1061 return Triple::MachO;
1062 return Triple::ELF;
1063
1064 case Triple::systemz:
1065 if (T.isOSzOS())
1066 return Triple::GOFF;
1067 return Triple::ELF;
1068
1069 case Triple::wasm32:
1070 case Triple::wasm64:
1071 return Triple::Wasm;
1072
1073 case Triple::spirv:
1074 case Triple::spirv32:
1075 case Triple::spirv64:
1076 return Triple::SPIRV;
1077
1078 case Triple::dxil:
1079 return Triple::DXContainer;
1080 }
1081 llvm_unreachable("unknown architecture");
1082}
1083
1084/// Construct a triple from the string representation provided.
1085///
1086/// This stores the string representation and parses the various pieces into
1087/// enum members.
1088Triple::Triple(std::string &&Str) : Data(std::move(Str)) {
1089 // Do minimal parsing by hand here.
1090 SmallVector<StringRef, 4> Components;
1091 StringRef(Data).split(A&: Components, Separator: '-', /*MaxSplit*/ 3);
1092 if (Components.size() > 0) {
1093 Arch = parseArch(ArchName: Components[0]);
1094 SubArch = parseSubArch(SubArchName: Components[0]);
1095 if (Components.size() > 1) {
1096 Vendor = parseVendor(VendorName: Components[1]);
1097 if (Components.size() > 2) {
1098 OS = parseOS(OSName: Components[2]);
1099 if (Components.size() > 3) {
1100 Environment = parseEnvironment(EnvironmentName: Components[3]);
1101 ObjectFormat = parseFormat(EnvironmentName: Components[3]);
1102 }
1103 }
1104 } else {
1105 Environment =
1106 StringSwitch<Triple::EnvironmentType>(Components[0])
1107 .StartsWith(S: "mipsn32", Value: Triple::GNUABIN32)
1108 .StartsWith(S: "mips64", Value: Triple::GNUABI64)
1109 .StartsWith(S: "mipsisa64", Value: Triple::GNUABI64)
1110 .StartsWith(S: "mipsisa32", Value: Triple::GNU)
1111 .Cases(CaseStrings: {"mips", "mipsel", "mipsr6", "mipsr6el"}, Value: Triple::GNU)
1112 .Default(Value: UnknownEnvironment);
1113 }
1114 }
1115 if (ObjectFormat == UnknownObjectFormat)
1116 ObjectFormat = getDefaultFormat(T: *this);
1117}
1118
1119Triple::Triple(const Twine &Str) : Triple(Str.str()) {}
1120
1121/// Construct a triple from string representations of the architecture,
1122/// vendor, and OS.
1123///
1124/// This joins each argument into a canonical string representation and parses
1125/// them into enum members. It leaves the environment unknown and omits it from
1126/// the string representation.
1127Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
1128 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
1129 Arch(parseArch(ArchName: ArchStr.str())), SubArch(parseSubArch(SubArchName: ArchStr.str())),
1130 Vendor(parseVendor(VendorName: VendorStr.str())), OS(parseOS(OSName: OSStr.str())),
1131 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
1132 ObjectFormat = getDefaultFormat(T: *this);
1133}
1134
1135/// Construct a triple from string representations of the architecture,
1136/// vendor, OS, and environment.
1137///
1138/// This joins each argument into a canonical string representation and parses
1139/// them into enum members.
1140Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
1141 const Twine &EnvironmentStr)
1142 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
1143 EnvironmentStr)
1144 .str()),
1145 Arch(parseArch(ArchName: ArchStr.str())), SubArch(parseSubArch(SubArchName: ArchStr.str())),
1146 Vendor(parseVendor(VendorName: VendorStr.str())), OS(parseOS(OSName: OSStr.str())),
1147 Environment(parseEnvironment(EnvironmentName: EnvironmentStr.str())),
1148 ObjectFormat(parseFormat(EnvironmentName: EnvironmentStr.str())) {
1149 if (ObjectFormat == Triple::UnknownObjectFormat)
1150 ObjectFormat = getDefaultFormat(T: *this);
1151}
1152
1153Triple::Triple(ArchType A, SubArchType SA, VendorType V, OSType OS)
1154 : Data((getArchName(Kind: A, SubArch: SA) + Twine('-') + getVendorTypeName(Kind: V) +
1155 Twine('-') + getOSTypeName(Kind: OS))
1156 .str()),
1157 Arch(A), SubArch(SA), Vendor(V), OS(OS),
1158 ObjectFormat(getDefaultFormat(T: *this)) {}
1159
1160Triple::Triple(ArchType A, SubArchType SA, VendorType V, OSType OS,
1161 EnvironmentType E)
1162 : Data((getArchName(Kind: A, SubArch: SA) + Twine('-') + getVendorTypeName(Kind: V) +
1163 Twine('-') + getOSTypeName(Kind: OS) + Twine('-') +
1164 getEnvironmentTypeName(Kind: E))
1165 .str()),
1166 Arch(A), SubArch(SA), Vendor(V), OS(OS), Environment(E),
1167 ObjectFormat(getDefaultFormat(T: *this)) {}
1168
1169Triple::Triple(ArchType A, SubArchType SA, VendorType V, OSType OS,
1170 EnvironmentType E, ObjectFormatType OF)
1171 : Data((getArchName(Kind: A, SubArch: SA) + Twine('-') + getVendorTypeName(Kind: V) +
1172 Twine('-') + getOSTypeName(Kind: OS) + Twine('-') +
1173 getEnvironmentTypeName(Kind: E) + Twine('-') +
1174 getObjectFormatTypeName(Kind: OF))
1175 .str()),
1176 Arch(A), SubArch(SA), Vendor(V), OS(OS), Environment(E),
1177 ObjectFormat(OF) {}
1178
1179static VersionTuple parseVersionFromName(StringRef Name);
1180
1181static StringRef getDXILArchNameFromShaderModel(StringRef ShaderModelStr) {
1182 VersionTuple Ver =
1183 parseVersionFromName(Name: ShaderModelStr.drop_front(N: strlen(s: "shadermodel")));
1184 // Default DXIL minor version when Shader Model version is anything other
1185 // than 6.[0...9] or 6.x (which translates to latest current SM version)
1186 const unsigned SMMajor = 6;
1187 if (!Ver.empty()) {
1188 if (Ver.getMajor() == SMMajor) {
1189 if (std::optional<unsigned> SMMinor = Ver.getMinor()) {
1190 switch (*SMMinor) {
1191 case 0:
1192 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_0);
1193 case 1:
1194 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_1);
1195 case 2:
1196 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_2);
1197 case 3:
1198 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_3);
1199 case 4:
1200 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_4);
1201 case 5:
1202 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_5);
1203 case 6:
1204 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_6);
1205 case 7:
1206 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_7);
1207 case 8:
1208 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_8);
1209 case 9:
1210 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_9);
1211 default:
1212 report_fatal_error(reason: "Unsupported Shader Model version", gen_crash_diag: false);
1213 }
1214 }
1215 }
1216 } else {
1217 // Special case: DXIL minor version is set to LatestCurrentDXILMinor for
1218 // shadermodel6.x is
1219 if (ShaderModelStr == "shadermodel6.x") {
1220 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::LatestDXILSubArch);
1221 }
1222 }
1223 // DXIL version corresponding to Shader Model version other than 6.Minor
1224 // is 1.0
1225 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_0);
1226}
1227
1228std::string Triple::normalize(StringRef Str, CanonicalForm Form) {
1229 bool IsMinGW32 = false;
1230 bool IsCygwin = false;
1231
1232 // Parse into components.
1233 SmallVector<StringRef, 4> Components;
1234 Str.split(A&: Components, Separator: '-');
1235
1236 // If the first component corresponds to a known architecture, preferentially
1237 // use it for the architecture. If the second component corresponds to a
1238 // known vendor, preferentially use it for the vendor, etc. This avoids silly
1239 // component movement when a component parses as (eg) both a valid arch and a
1240 // valid os.
1241 ArchType Arch = UnknownArch;
1242 if (Components.size() > 0)
1243 Arch = parseArch(ArchName: Components[0]);
1244 VendorType Vendor = UnknownVendor;
1245 if (Components.size() > 1)
1246 Vendor = parseVendor(VendorName: Components[1]);
1247 OSType OS = UnknownOS;
1248 if (Components.size() > 2) {
1249 OS = parseOS(OSName: Components[2]);
1250 IsCygwin = Components[2].starts_with(Prefix: "cygwin") ||
1251 Components[2].starts_with(Prefix: "msys");
1252 IsMinGW32 = Components[2].starts_with(Prefix: "mingw");
1253 }
1254 EnvironmentType Environment = UnknownEnvironment;
1255 if (Components.size() > 3)
1256 Environment = parseEnvironment(EnvironmentName: Components[3]);
1257 ObjectFormatType ObjectFormat = UnknownObjectFormat;
1258 if (Components.size() > 4)
1259 ObjectFormat = parseFormat(EnvironmentName: Components[4]);
1260
1261 // Note which components are already in their final position. These will not
1262 // be moved.
1263 bool Found[4];
1264 Found[0] = Arch != UnknownArch;
1265 Found[1] = Vendor != UnknownVendor;
1266 Found[2] = OS != UnknownOS;
1267 Found[3] = Environment != UnknownEnvironment;
1268
1269 // If they are not there already, permute the components into their canonical
1270 // positions by seeing if they parse as a valid architecture, and if so moving
1271 // the component to the architecture position etc.
1272 for (unsigned Pos = 0; Pos != std::size(Found); ++Pos) {
1273 if (Found[Pos])
1274 continue; // Already in the canonical position.
1275
1276 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
1277 // Do not reparse any components that already matched.
1278 if (Idx < std::size(Found) && Found[Idx])
1279 continue;
1280
1281 // Does this component parse as valid for the target position?
1282 bool Valid = false;
1283 StringRef Comp = Components[Idx];
1284 switch (Pos) {
1285 default:
1286 llvm_unreachable("unexpected component type!");
1287 case 0:
1288 Arch = parseArch(ArchName: Comp);
1289 Valid = Arch != UnknownArch;
1290 break;
1291 case 1:
1292 Vendor = parseVendor(VendorName: Comp);
1293 Valid = Vendor != UnknownVendor;
1294 break;
1295 case 2:
1296 OS = parseOS(OSName: Comp);
1297 IsCygwin = Comp.starts_with(Prefix: "cygwin") || Comp.starts_with(Prefix: "msys");
1298 IsMinGW32 = Comp.starts_with(Prefix: "mingw");
1299 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
1300 break;
1301 case 3:
1302 Environment = parseEnvironment(EnvironmentName: Comp);
1303 Valid = Environment != UnknownEnvironment;
1304 if (!Valid) {
1305 ObjectFormat = parseFormat(EnvironmentName: Comp);
1306 Valid = ObjectFormat != UnknownObjectFormat;
1307 }
1308 break;
1309 }
1310 if (!Valid)
1311 continue; // Nope, try the next component.
1312
1313 // Move the component to the target position, pushing any non-fixed
1314 // components that are in the way to the right. This tends to give
1315 // good results in the common cases of a forgotten vendor component
1316 // or a wrongly positioned environment.
1317 if (Pos < Idx) {
1318 // Insert left, pushing the existing components to the right. For
1319 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
1320 StringRef CurrentComponent(""); // The empty component.
1321 // Replace the component we are moving with an empty component.
1322 std::swap(a&: CurrentComponent, b&: Components[Idx]);
1323 // Insert the component being moved at Pos, displacing any existing
1324 // components to the right.
1325 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
1326 // Skip over any fixed components.
1327 while (i < std::size(Found) && Found[i])
1328 ++i;
1329 // Place the component at the new position, getting the component
1330 // that was at this position - it will be moved right.
1331 std::swap(a&: CurrentComponent, b&: Components[i]);
1332 }
1333 } else if (Pos > Idx) {
1334 // Push right by inserting empty components until the component at Idx
1335 // reaches the target position Pos. For example, pc-a -> -pc-a when
1336 // moving pc to the second position.
1337 do {
1338 // Insert one empty component at Idx.
1339 StringRef CurrentComponent(""); // The empty component.
1340 for (unsigned i = Idx; i < Components.size();) {
1341 // Place the component at the new position, getting the component
1342 // that was at this position - it will be moved right.
1343 std::swap(a&: CurrentComponent, b&: Components[i]);
1344 // If it was placed on top of an empty component then we are done.
1345 if (CurrentComponent.empty())
1346 break;
1347 // Advance to the next component, skipping any fixed components.
1348 while (++i < std::size(Found) && Found[i])
1349 ;
1350 }
1351 // The last component was pushed off the end - append it.
1352 if (!CurrentComponent.empty())
1353 Components.push_back(Elt: CurrentComponent);
1354
1355 // Advance Idx to the component's new position.
1356 while (++Idx < std::size(Found) && Found[Idx])
1357 ;
1358 } while (Idx < Pos); // Add more until the final position is reached.
1359 }
1360 assert(Pos < Components.size() && Components[Pos] == Comp &&
1361 "Component moved wrong!");
1362 Found[Pos] = true;
1363 break;
1364 }
1365 }
1366
1367 // If "none" is in the middle component in a three-component triple, treat it
1368 // as the OS (Components[2]) instead of the vendor (Components[1]).
1369 if (Found[0] && !Found[1] && !Found[2] && Found[3] &&
1370 Components[1] == "none" && Components[2].empty())
1371 std::swap(a&: Components[1], b&: Components[2]);
1372
1373 // Replace empty components with "unknown" value.
1374 for (StringRef &C : Components)
1375 if (C.empty())
1376 C = "unknown";
1377
1378 // Special case logic goes here. At this point Arch, Vendor and OS have the
1379 // correct values for the computed components.
1380 std::string NormalizedEnvironment;
1381 if (Environment == Triple::Android &&
1382 Components[3].starts_with(Prefix: "androideabi")) {
1383 StringRef AndroidVersion = Components[3].drop_front(N: strlen(s: "androideabi"));
1384 if (AndroidVersion.empty()) {
1385 Components[3] = "android";
1386 } else {
1387 NormalizedEnvironment = Twine("android", AndroidVersion).str();
1388 Components[3] = NormalizedEnvironment;
1389 }
1390 }
1391
1392 // SUSE uses "gnueabi" to mean "gnueabihf"
1393 if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI)
1394 Components[3] = "gnueabihf";
1395
1396 if (OS == Triple::Win32) {
1397 Components.resize(N: 4);
1398 Components[2] = "windows";
1399 if (Environment == UnknownEnvironment) {
1400 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
1401 Components[3] = "msvc";
1402 else
1403 Components[3] = getObjectFormatTypeName(Kind: ObjectFormat);
1404 }
1405 } else if (IsMinGW32) {
1406 Components.resize(N: 4);
1407 Components[2] = "windows";
1408 Components[3] = "gnu";
1409 } else if (IsCygwin) {
1410 Components.resize(N: 4);
1411 Components[2] = "windows";
1412 Components[3] = "cygnus";
1413 }
1414 if (IsMinGW32 || IsCygwin ||
1415 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
1416 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
1417 Components.resize(N: 5);
1418 Components[4] = getObjectFormatTypeName(Kind: ObjectFormat);
1419 }
1420 }
1421
1422 // Normalize DXIL triple if it does not include DXIL version number.
1423 // Determine DXIL version number using the minor version number of Shader
1424 // Model version specified in target triple, if any. Prior to decoupling DXIL
1425 // version numbering from that of Shader Model DXIL version 1.Y corresponds to
1426 // SM 6.Y. E.g., dxilv1.Y-unknown-shadermodelX.Y-hull
1427 if (Components[0] == "dxil") {
1428 if (Components.size() > 4) {
1429 Components.resize(N: 4);
1430 }
1431 // Add DXIL version only if shadermodel is specified in the triple
1432 if (OS == Triple::ShaderModel) {
1433 Components[0] = getDXILArchNameFromShaderModel(ShaderModelStr: Components[2]);
1434 }
1435 }
1436
1437 // Currently the firmware OS is an Apple specific concept.
1438 if ((Components.size() > 2) && (Components[2] == "firmware") &&
1439 (Components[1] != "apple"))
1440 llvm::reportFatalUsageError(
1441 reason: "the firmware target os is only supported for the apple vendor");
1442
1443 // Canonicalize the components if necessary.
1444 switch (Form) {
1445 case CanonicalForm::ANY:
1446 break;
1447 case CanonicalForm::THREE_IDENT:
1448 case CanonicalForm::FOUR_IDENT:
1449 case CanonicalForm::FIVE_IDENT: {
1450 Components.resize(N: static_cast<unsigned>(Form), NV: "unknown");
1451 break;
1452 }
1453 }
1454
1455 // Stick the corrected components back together to form the normalized string.
1456 return join(R&: Components, Separator: "-");
1457}
1458
1459StringRef Triple::getArchName() const {
1460 return StringRef(Data).split(Separator: '-').first; // Isolate first component
1461}
1462
1463StringRef Triple::getVendorName() const {
1464 StringRef Tmp = StringRef(Data).split(Separator: '-').second; // Strip first component
1465 return Tmp.split(Separator: '-').first; // Isolate second component
1466}
1467
1468StringRef Triple::getOSName() const {
1469 StringRef Tmp = StringRef(Data).split(Separator: '-').second; // Strip first component
1470 Tmp = Tmp.split(Separator: '-').second; // Strip second component
1471 return Tmp.split(Separator: '-').first; // Isolate third component
1472}
1473
1474StringRef Triple::getEnvironmentName() const {
1475 StringRef Tmp = StringRef(Data).split(Separator: '-').second; // Strip first component
1476 Tmp = Tmp.split(Separator: '-').second; // Strip second component
1477 return Tmp.split(Separator: '-').second; // Strip third component
1478}
1479
1480StringRef Triple::getOSAndEnvironmentName() const {
1481 StringRef Tmp = StringRef(Data).split(Separator: '-').second; // Strip first component
1482 return Tmp.split(Separator: '-').second; // Strip second component
1483}
1484
1485static VersionTuple parseVersionFromName(StringRef Name) {
1486 VersionTuple Version;
1487 Version.tryParse(string: Name);
1488 return Version.withoutBuild();
1489}
1490
1491VersionTuple Triple::getEnvironmentVersion() const {
1492 return parseVersionFromName(Name: getEnvironmentVersionString());
1493}
1494
1495StringRef Triple::getEnvironmentVersionString() const {
1496 StringRef EnvironmentName = getEnvironmentName();
1497
1498 // none is a valid environment type - it basically amounts to a freestanding
1499 // environment.
1500 if (EnvironmentName == "none")
1501 return "";
1502
1503 StringRef EnvironmentTypeName = getEnvironmentTypeName(Kind: getEnvironment());
1504 EnvironmentName.consume_front(Prefix: EnvironmentTypeName);
1505
1506 if (EnvironmentName.contains(Other: "-")) {
1507 // -obj is the suffix
1508 if (getObjectFormat() != Triple::UnknownObjectFormat) {
1509 StringRef ObjectFormatTypeName =
1510 getObjectFormatTypeName(Kind: getObjectFormat());
1511 const std::string tmp = (Twine("-") + ObjectFormatTypeName).str();
1512 EnvironmentName.consume_back(Suffix: tmp);
1513 }
1514 }
1515 return EnvironmentName;
1516}
1517
1518VersionTuple Triple::getOSVersion() const {
1519 StringRef OSName = getOSName();
1520 // Assume that the OS portion of the triple starts with the canonical name.
1521 StringRef OSTypeName = getOSTypeName(Kind: getOS());
1522 if (OSName.starts_with(Prefix: OSTypeName))
1523 OSName = OSName.substr(Start: OSTypeName.size());
1524 else if (getOS() == MacOSX)
1525 OSName.consume_front(Prefix: "macos");
1526 else if (OSName.starts_with(Prefix: "visionos"))
1527 OSName.consume_front(Prefix: "visionos");
1528
1529 return parseVersionFromName(Name: OSName);
1530}
1531
1532bool Triple::getMacOSXVersion(VersionTuple &Version) const {
1533 Version = getOSVersion();
1534
1535 switch (getOS()) {
1536 default:
1537 llvm_unreachable("unexpected OS for Darwin triple");
1538 case Darwin:
1539 // Default to darwin8, i.e., MacOSX 10.4.
1540 if (Version.getMajor() == 0)
1541 Version = VersionTuple(8);
1542 // Darwin version numbers are skewed from OS X versions.
1543 if (Version.getMajor() < 4) {
1544 return false;
1545 }
1546 if (Version.getMajor() <= 19) {
1547 Version = VersionTuple(10, Version.getMajor() - 4);
1548 } else if (Version.getMajor() < 25) {
1549 // darwin20-24 corresponds to macOS 11-15.
1550 Version = VersionTuple(11 + Version.getMajor() - 20);
1551 } else if ((Version.getMajor() == 25) || (Version.getMajor() == 26)) {
1552 // darwin25-26 corresponds to macOS 26-27.
1553 Version = VersionTuple(Version.getMajor() + 1);
1554 } else {
1555 // Starting with darwin27, it naturally corresponds to the same macOS
1556 // version.
1557 }
1558 break;
1559 case MacOSX:
1560 // Default to 10.4.
1561 if (Version.getMajor() == 0) {
1562 Version = VersionTuple(10, 4);
1563 } else if (Version.getMajor() < 10) {
1564 return false;
1565 }
1566 break;
1567 case IOS:
1568 case TvOS:
1569 case WatchOS:
1570 // Ignore the version from the triple. This is only handled because the
1571 // the clang driver combines OS X and IOS support into a common Darwin
1572 // toolchain that wants to know the OS X version number even when targeting
1573 // IOS.
1574 Version = VersionTuple(10, 4);
1575 break;
1576 case XROS:
1577 llvm_unreachable("OSX version isn't relevant for xrOS");
1578 case DriverKit:
1579 llvm_unreachable("OSX version isn't relevant for DriverKit");
1580 case Firmware:
1581 llvm_unreachable("OSX version isn't relevant for Firmware");
1582 }
1583 return true;
1584}
1585
1586VersionTuple Triple::getiOSVersion() const {
1587 switch (getOS()) {
1588 default:
1589 llvm_unreachable("unexpected OS for Darwin triple");
1590 case Darwin:
1591 case MacOSX:
1592 // Ignore the version from the triple. This is only handled because the
1593 // the clang driver combines OS X and IOS support into a common Darwin
1594 // toolchain that wants to know the iOS version number even when targeting
1595 // OS X.
1596 return VersionTuple(5);
1597 case IOS:
1598 case TvOS: {
1599 VersionTuple Version = getOSVersion();
1600 // Default to 5.0 (or 7.0 for arm64).
1601 if (Version.getMajor() == 0)
1602 return (getArch() == aarch64) ? VersionTuple(7) : VersionTuple(5);
1603 if (Version.getMajor() == 19)
1604 // tvOS 19 corresponds to ios26.
1605 return VersionTuple(26);
1606 return getCanonicalVersionForOS(OSKind: OSType::IOS, Version,
1607 IsInValidRange: isValidVersionForOS(OSKind: OSType::IOS, Version));
1608 }
1609 case XROS: {
1610 VersionTuple Version = getOSVersion();
1611 // xrOS 1 is aligned with iOS 17.
1612 if (Version.getMajor() < 3)
1613 return Version.withMajorReplaced(NewMajor: Version.getMajor() + 16);
1614 // visionOS 3 corresponds to ios 26+.
1615 if (Version.getMajor() == 3)
1616 return VersionTuple(26);
1617 return getCanonicalVersionForOS(OSKind: OSType::XROS, Version,
1618 IsInValidRange: isValidVersionForOS(OSKind: OSType::XROS, Version));
1619 }
1620 case WatchOS: {
1621 VersionTuple Version = getOSVersion();
1622 // watchOS 12 corresponds to ios 26.
1623 if (Version.getMajor() == 12)
1624 return VersionTuple(26);
1625 return getCanonicalVersionForOS(
1626 OSKind: OSType::WatchOS, Version,
1627 IsInValidRange: isValidVersionForOS(OSKind: OSType::WatchOS, Version));
1628 }
1629 case BridgeOS:
1630 llvm_unreachable("conflicting triple info");
1631 case DriverKit:
1632 llvm_unreachable("DriverKit doesn't have an iOS version");
1633 case Firmware:
1634 llvm_unreachable("iOS version isn't relevant for Firmware");
1635 }
1636}
1637
1638VersionTuple Triple::getWatchOSVersion() const {
1639 switch (getOS()) {
1640 default:
1641 llvm_unreachable("unexpected OS for Darwin triple");
1642 case Darwin:
1643 case MacOSX:
1644 // Ignore the version from the triple. This is only handled because the
1645 // the clang driver combines OS X and IOS support into a common Darwin
1646 // toolchain that wants to know the iOS version number even when targeting
1647 // OS X.
1648 return VersionTuple(2);
1649 case WatchOS: {
1650 VersionTuple Version = getOSVersion();
1651 if (Version.getMajor() == 0)
1652 return VersionTuple(2);
1653 return Version;
1654 }
1655 case IOS:
1656 llvm_unreachable("conflicting triple info");
1657 case XROS:
1658 llvm_unreachable("watchOS version isn't relevant for xrOS");
1659 case DriverKit:
1660 llvm_unreachable("DriverKit doesn't have a WatchOS version");
1661 case Firmware:
1662 llvm_unreachable("watchOS version isn't relevant for Firmware");
1663 }
1664}
1665
1666VersionTuple Triple::getDriverKitVersion() const {
1667 switch (getOS()) {
1668 default:
1669 llvm_unreachable("unexpected OS for Darwin triple");
1670 case DriverKit:
1671 VersionTuple Version = getOSVersion();
1672 if (Version.getMajor() == 0)
1673 return Version.withMajorReplaced(NewMajor: 19);
1674 return Version;
1675 }
1676}
1677
1678VersionTuple Triple::getVulkanVersion() const {
1679 if (getArch() != spirv || getOS() != Vulkan)
1680 llvm_unreachable("invalid Vulkan SPIR-V triple");
1681
1682 VersionTuple VulkanVersion = getOSVersion();
1683 SubArchType SpirvVersion = getSubArch();
1684
1685 llvm::DenseMap<VersionTuple, SubArchType> ValidVersionMap = {
1686 // Vulkan 1.2 -> SPIR-V 1.5.
1687 {VersionTuple(1, 2), SPIRVSubArch_v15},
1688 // Vulkan 1.3 -> SPIR-V 1.6.
1689 {VersionTuple(1, 3), SPIRVSubArch_v16}};
1690
1691 // If Vulkan version is unset, default to 1.2.
1692 if (VulkanVersion == VersionTuple(0))
1693 VulkanVersion = VersionTuple(1, 2);
1694
1695 if (ValidVersionMap.contains(Val: VulkanVersion) &&
1696 (ValidVersionMap.lookup(Val: VulkanVersion) == SpirvVersion ||
1697 SpirvVersion == NoSubArch))
1698 return VulkanVersion;
1699
1700 return VersionTuple(0);
1701}
1702
1703VersionTuple Triple::getDXILVersion() const {
1704 if (getArch() != dxil || getOS() != ShaderModel)
1705 llvm_unreachable("invalid DXIL triple");
1706 StringRef Arch = getArchName();
1707 if (getSubArch() == NoSubArch)
1708 Arch = getDXILArchNameFromShaderModel(ShaderModelStr: getOSName());
1709 Arch.consume_front(Prefix: "dxilv");
1710 VersionTuple DXILVersion = parseVersionFromName(Name: Arch);
1711 // FIXME: validate DXIL version against Shader Model version.
1712 // Tracked by https://github.com/llvm/llvm-project/issues/91388
1713 return DXILVersion;
1714}
1715
1716void Triple::setTriple(const Twine &Str) { *this = Triple(Str); }
1717
1718void Triple::setArch(ArchType Kind, SubArchType SubArch) {
1719 setArchName(getArchName(Kind, SubArch));
1720}
1721
1722void Triple::setVendor(VendorType Kind) {
1723 setVendorName(getVendorTypeName(Kind));
1724}
1725
1726void Triple::setOS(OSType Kind) { setOSName(getOSTypeName(Kind)); }
1727
1728void Triple::setEnvironment(EnvironmentType Kind) {
1729 if (ObjectFormat == getDefaultFormat(T: *this))
1730 return setEnvironmentName(getEnvironmentTypeName(Kind));
1731
1732 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1733 getObjectFormatTypeName(Kind: ObjectFormat))
1734 .str());
1735}
1736
1737void Triple::setObjectFormat(ObjectFormatType Kind) {
1738 if (Environment == UnknownEnvironment)
1739 return setEnvironmentName(getObjectFormatTypeName(Kind));
1740
1741 setEnvironmentName((getEnvironmentTypeName(Kind: Environment) + Twine("-") +
1742 getObjectFormatTypeName(Kind))
1743 .str());
1744}
1745
1746void Triple::setArchName(StringRef Str) {
1747 setTriple(Str + "-" + getVendorName() + "-" + getOSAndEnvironmentName());
1748}
1749
1750void Triple::setVendorName(StringRef Str) {
1751 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1752}
1753
1754void Triple::setOSName(StringRef Str) {
1755 if (hasEnvironment())
1756 setTriple(getArchName() + "-" + getVendorName() + "-" + Str + "-" +
1757 getEnvironmentName());
1758 else
1759 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1760}
1761
1762void Triple::setEnvironmentName(StringRef Str) {
1763 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() + "-" +
1764 Str);
1765}
1766
1767void Triple::setOSAndEnvironmentName(StringRef Str) {
1768 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1769}
1770
1771unsigned Triple::getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1772 switch (Arch) {
1773 case llvm::Triple::UnknownArch:
1774 return 0;
1775
1776 case llvm::Triple::avr:
1777 case llvm::Triple::msp430:
1778 return 16;
1779
1780 case llvm::Triple::aarch64_32:
1781 case llvm::Triple::amdil:
1782 case llvm::Triple::arc:
1783 case llvm::Triple::arm:
1784 case llvm::Triple::armeb:
1785 case llvm::Triple::csky:
1786 case llvm::Triple::dxil:
1787 case llvm::Triple::hexagon:
1788 case llvm::Triple::hsail:
1789 case llvm::Triple::kalimba:
1790 case llvm::Triple::lanai:
1791 case llvm::Triple::loongarch32:
1792 case llvm::Triple::m68k:
1793 case llvm::Triple::mips:
1794 case llvm::Triple::mipsel:
1795 case llvm::Triple::nvptx:
1796 case llvm::Triple::ppc:
1797 case llvm::Triple::ppcle:
1798 case llvm::Triple::r600:
1799 case llvm::Triple::renderscript32:
1800 case llvm::Triple::riscv32:
1801 case llvm::Triple::riscv32be:
1802 case llvm::Triple::shave:
1803 case llvm::Triple::sparc:
1804 case llvm::Triple::sparcel:
1805 case llvm::Triple::spir:
1806 case llvm::Triple::spirv32:
1807 case llvm::Triple::tce:
1808 case llvm::Triple::tcele:
1809 case llvm::Triple::thumb:
1810 case llvm::Triple::thumbeb:
1811 case llvm::Triple::wasm32:
1812 case llvm::Triple::x86:
1813 case llvm::Triple::xcore:
1814 case llvm::Triple::xtensa:
1815 return 32;
1816
1817 case llvm::Triple::aarch64:
1818 case llvm::Triple::aarch64_be:
1819 case llvm::Triple::amdgpu:
1820 case llvm::Triple::amdil64:
1821 case llvm::Triple::bpfeb:
1822 case llvm::Triple::bpfel:
1823 case llvm::Triple::hsail64:
1824 case llvm::Triple::loongarch64:
1825 case llvm::Triple::mips64:
1826 case llvm::Triple::mips64el:
1827 case llvm::Triple::nvptx64:
1828 case llvm::Triple::ppc64:
1829 case llvm::Triple::ppc64le:
1830 case llvm::Triple::renderscript64:
1831 case llvm::Triple::riscv64:
1832 case llvm::Triple::riscv64be:
1833 case llvm::Triple::sparcv9:
1834 case llvm::Triple::spirv:
1835 case llvm::Triple::spir64:
1836 case llvm::Triple::spirv64:
1837 case llvm::Triple::tcele64:
1838 case llvm::Triple::systemz:
1839 case llvm::Triple::ve:
1840 case llvm::Triple::wasm64:
1841 case llvm::Triple::x86_64:
1842 return 64;
1843 }
1844 llvm_unreachable("Invalid architecture value");
1845}
1846
1847unsigned Triple::getTrampolineSize() const {
1848 switch (getArch()) {
1849 default:
1850 break;
1851 case Triple::ppc:
1852 case Triple::ppcle:
1853 if (isOSLinux())
1854 return 40;
1855 break;
1856 case Triple::ppc64:
1857 case Triple::ppc64le:
1858 if (isOSLinux())
1859 return 48;
1860 break;
1861 }
1862 return 32;
1863}
1864
1865bool Triple::isArch64Bit() const {
1866 return getArchPointerBitWidth(Arch: getArch()) == 64;
1867}
1868
1869bool Triple::isArch32Bit() const {
1870 return getArchPointerBitWidth(Arch: getArch()) == 32;
1871}
1872
1873bool Triple::isArch16Bit() const {
1874 return getArchPointerBitWidth(Arch: getArch()) == 16;
1875}
1876
1877Triple Triple::get32BitArchVariant() const {
1878 Triple T(*this);
1879 switch (getArch()) {
1880 case Triple::UnknownArch:
1881 case Triple::amdgpu:
1882 case Triple::avr:
1883 case Triple::bpfeb:
1884 case Triple::bpfel:
1885 case Triple::msp430:
1886 case Triple::systemz:
1887 case Triple::ve:
1888 T.setArch(Kind: UnknownArch);
1889 break;
1890
1891 case Triple::aarch64_32:
1892 case Triple::amdil:
1893 case Triple::arc:
1894 case Triple::arm:
1895 case Triple::armeb:
1896 case Triple::csky:
1897 case Triple::dxil:
1898 case Triple::hexagon:
1899 case Triple::hsail:
1900 case Triple::kalimba:
1901 case Triple::lanai:
1902 case Triple::loongarch32:
1903 case Triple::m68k:
1904 case Triple::mips:
1905 case Triple::mipsel:
1906 case Triple::nvptx:
1907 case Triple::ppc:
1908 case Triple::ppcle:
1909 case Triple::r600:
1910 case Triple::renderscript32:
1911 case Triple::riscv32:
1912 case Triple::riscv32be:
1913 case Triple::shave:
1914 case Triple::sparc:
1915 case Triple::sparcel:
1916 case Triple::spir:
1917 case Triple::spirv32:
1918 case Triple::tce:
1919 case Triple::tcele:
1920 case Triple::thumb:
1921 case Triple::thumbeb:
1922 case Triple::wasm32:
1923 case Triple::x86:
1924 case Triple::xcore:
1925 case Triple::xtensa:
1926 // Already 32-bit.
1927 break;
1928
1929 case Triple::aarch64:
1930 T.setArch(Kind: Triple::arm);
1931 break;
1932 case Triple::aarch64_be:
1933 T.setArch(Kind: Triple::armeb);
1934 break;
1935 case Triple::amdil64:
1936 T.setArch(Kind: Triple::amdil);
1937 break;
1938 case Triple::hsail64:
1939 T.setArch(Kind: Triple::hsail);
1940 break;
1941 case Triple::loongarch64:
1942 T.setArch(Kind: Triple::loongarch32);
1943 break;
1944 case Triple::mips64:
1945 T.setArch(Kind: Triple::mips, SubArch: getSubArch());
1946 break;
1947 case Triple::mips64el:
1948 T.setArch(Kind: Triple::mipsel, SubArch: getSubArch());
1949 break;
1950 case Triple::nvptx64:
1951 T.setArch(Kind: Triple::nvptx);
1952 break;
1953 case Triple::ppc64:
1954 T.setArch(Kind: Triple::ppc);
1955 break;
1956 case Triple::ppc64le:
1957 T.setArch(Kind: Triple::ppcle);
1958 break;
1959 case Triple::renderscript64:
1960 T.setArch(Kind: Triple::renderscript32);
1961 break;
1962 case Triple::riscv64:
1963 T.setArch(Kind: Triple::riscv32);
1964 break;
1965 case Triple::riscv64be:
1966 T.setArch(Kind: Triple::riscv32be);
1967 break;
1968 case Triple::sparcv9:
1969 T.setArch(Kind: Triple::sparc);
1970 break;
1971 case Triple::spir64:
1972 T.setArch(Kind: Triple::spir);
1973 break;
1974 case Triple::spirv:
1975 case Triple::spirv64:
1976 T.setArch(Kind: Triple::spirv32, SubArch: getSubArch());
1977 break;
1978 case Triple::tcele64:
1979 T.setArch(Kind: Triple::tcele);
1980 break;
1981 case Triple::wasm64:
1982 T.setArch(Kind: Triple::wasm32);
1983 break;
1984 case Triple::x86_64:
1985 T.setArch(Kind: Triple::x86);
1986 break;
1987 }
1988 return T;
1989}
1990
1991Triple Triple::get64BitArchVariant() const {
1992 Triple T(*this);
1993 switch (getArch()) {
1994 case Triple::UnknownArch:
1995 case Triple::arc:
1996 case Triple::avr:
1997 case Triple::csky:
1998 case Triple::dxil:
1999 case Triple::hexagon:
2000 case Triple::kalimba:
2001 case Triple::lanai:
2002 case Triple::m68k:
2003 case Triple::msp430:
2004 case Triple::r600:
2005 case Triple::shave:
2006 case Triple::sparcel:
2007 case Triple::tce:
2008 case Triple::xcore:
2009 case Triple::xtensa:
2010 T.setArch(Kind: UnknownArch);
2011 break;
2012
2013 case Triple::aarch64:
2014 case Triple::aarch64_be:
2015 case Triple::amdgpu:
2016 case Triple::amdil64:
2017 case Triple::bpfeb:
2018 case Triple::bpfel:
2019 case Triple::hsail64:
2020 case Triple::loongarch64:
2021 case Triple::mips64:
2022 case Triple::mips64el:
2023 case Triple::nvptx64:
2024 case Triple::ppc64:
2025 case Triple::ppc64le:
2026 case Triple::renderscript64:
2027 case Triple::riscv64:
2028 case Triple::riscv64be:
2029 case Triple::sparcv9:
2030 case Triple::spir64:
2031 case Triple::spirv64:
2032 case Triple::systemz:
2033 case Triple::tcele64:
2034 case Triple::ve:
2035 case Triple::wasm64:
2036 case Triple::x86_64:
2037 // Already 64-bit.
2038 break;
2039
2040 case Triple::aarch64_32:
2041 T.setArch(Kind: Triple::aarch64);
2042 break;
2043 case Triple::amdil:
2044 T.setArch(Kind: Triple::amdil64);
2045 break;
2046 case Triple::arm:
2047 T.setArch(Kind: Triple::aarch64);
2048 break;
2049 case Triple::armeb:
2050 T.setArch(Kind: Triple::aarch64_be);
2051 break;
2052 case Triple::hsail:
2053 T.setArch(Kind: Triple::hsail64);
2054 break;
2055 case Triple::loongarch32:
2056 T.setArch(Kind: Triple::loongarch64);
2057 break;
2058 case Triple::mips:
2059 T.setArch(Kind: Triple::mips64, SubArch: getSubArch());
2060 break;
2061 case Triple::mipsel:
2062 T.setArch(Kind: Triple::mips64el, SubArch: getSubArch());
2063 break;
2064 case Triple::nvptx:
2065 T.setArch(Kind: Triple::nvptx64);
2066 break;
2067 case Triple::ppc:
2068 T.setArch(Kind: Triple::ppc64);
2069 break;
2070 case Triple::ppcle:
2071 T.setArch(Kind: Triple::ppc64le);
2072 break;
2073 case Triple::renderscript32:
2074 T.setArch(Kind: Triple::renderscript64);
2075 break;
2076 case Triple::riscv32:
2077 T.setArch(Kind: Triple::riscv64);
2078 break;
2079 case Triple::riscv32be:
2080 T.setArch(Kind: Triple::riscv64be);
2081 break;
2082 case Triple::sparc:
2083 T.setArch(Kind: Triple::sparcv9);
2084 break;
2085 case Triple::spir:
2086 T.setArch(Kind: Triple::spir64);
2087 break;
2088 case Triple::spirv:
2089 case Triple::spirv32:
2090 T.setArch(Kind: Triple::spirv64, SubArch: getSubArch());
2091 break;
2092 case Triple::tcele:
2093 T.setArch(Kind: Triple::tcele64);
2094 break;
2095 case Triple::thumb:
2096 T.setArch(Kind: Triple::aarch64);
2097 break;
2098 case Triple::thumbeb:
2099 T.setArch(Kind: Triple::aarch64_be);
2100 break;
2101 case Triple::wasm32:
2102 T.setArch(Kind: Triple::wasm64);
2103 break;
2104 case Triple::x86:
2105 T.setArch(Kind: Triple::x86_64);
2106 break;
2107 }
2108 return T;
2109}
2110
2111Triple Triple::getBigEndianArchVariant() const {
2112 Triple T(*this);
2113 // Already big endian.
2114 if (!isLittleEndian())
2115 return T;
2116 switch (getArch()) {
2117 case Triple::UnknownArch:
2118 case Triple::amdgpu:
2119 case Triple::amdil64:
2120 case Triple::amdil:
2121 case Triple::avr:
2122 case Triple::dxil:
2123 case Triple::hexagon:
2124 case Triple::hsail64:
2125 case Triple::hsail:
2126 case Triple::kalimba:
2127 case Triple::loongarch32:
2128 case Triple::loongarch64:
2129 case Triple::msp430:
2130 case Triple::nvptx64:
2131 case Triple::nvptx:
2132 case Triple::r600:
2133 case Triple::renderscript32:
2134 case Triple::renderscript64:
2135 case Triple::shave:
2136 case Triple::spir64:
2137 case Triple::spir:
2138 case Triple::spirv:
2139 case Triple::spirv32:
2140 case Triple::spirv64:
2141 case Triple::tcele64:
2142 case Triple::wasm32:
2143 case Triple::wasm64:
2144 case Triple::x86:
2145 case Triple::x86_64:
2146 case Triple::xcore:
2147 case Triple::ve:
2148 case Triple::csky:
2149 case Triple::xtensa:
2150
2151 // ARM is intentionally unsupported here, changing the architecture would
2152 // drop any arch suffixes.
2153 case Triple::arm:
2154 case Triple::thumb:
2155 T.setArch(Kind: UnknownArch);
2156 break;
2157
2158 case Triple::aarch64:
2159 T.setArch(Kind: Triple::aarch64_be);
2160 break;
2161 case Triple::bpfel:
2162 T.setArch(Kind: Triple::bpfeb);
2163 break;
2164 case Triple::mips64el:
2165 T.setArch(Kind: Triple::mips64, SubArch: getSubArch());
2166 break;
2167 case Triple::mipsel:
2168 T.setArch(Kind: Triple::mips, SubArch: getSubArch());
2169 break;
2170 case Triple::ppcle:
2171 T.setArch(Kind: Triple::ppc);
2172 break;
2173 case Triple::ppc64le:
2174 T.setArch(Kind: Triple::ppc64);
2175 break;
2176 case Triple::riscv32:
2177 T.setArch(Kind: Triple::riscv32be);
2178 break;
2179 case Triple::riscv64:
2180 T.setArch(Kind: Triple::riscv64be);
2181 break;
2182 case Triple::sparcel:
2183 T.setArch(Kind: Triple::sparc);
2184 break;
2185 case Triple::tcele:
2186 T.setArch(Kind: Triple::tce);
2187 break;
2188 default:
2189 llvm_unreachable("getBigEndianArchVariant: unknown triple.");
2190 }
2191 return T;
2192}
2193
2194Triple Triple::getLittleEndianArchVariant() const {
2195 Triple T(*this);
2196 if (isLittleEndian())
2197 return T;
2198
2199 switch (getArch()) {
2200 case Triple::UnknownArch:
2201 case Triple::lanai:
2202 case Triple::sparcv9:
2203 case Triple::systemz:
2204 case Triple::m68k:
2205
2206 // ARM is intentionally unsupported here, changing the architecture would
2207 // drop any arch suffixes.
2208 case Triple::armeb:
2209 case Triple::thumbeb:
2210 T.setArch(Kind: UnknownArch);
2211 break;
2212
2213 case Triple::aarch64_be:
2214 T.setArch(Kind: Triple::aarch64);
2215 break;
2216 case Triple::bpfeb:
2217 T.setArch(Kind: Triple::bpfel);
2218 break;
2219 case Triple::mips64:
2220 T.setArch(Kind: Triple::mips64el, SubArch: getSubArch());
2221 break;
2222 case Triple::mips:
2223 T.setArch(Kind: Triple::mipsel, SubArch: getSubArch());
2224 break;
2225 case Triple::ppc:
2226 T.setArch(Kind: Triple::ppcle);
2227 break;
2228 case Triple::ppc64:
2229 T.setArch(Kind: Triple::ppc64le);
2230 break;
2231 case Triple::riscv32be:
2232 T.setArch(Kind: Triple::riscv32);
2233 break;
2234 case Triple::riscv64be:
2235 T.setArch(Kind: Triple::riscv64);
2236 break;
2237 case Triple::sparc:
2238 T.setArch(Kind: Triple::sparcel);
2239 break;
2240 case Triple::tce:
2241 T.setArch(Kind: Triple::tcele);
2242 break;
2243 default:
2244 llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
2245 }
2246 return T;
2247}
2248
2249bool Triple::isLittleEndian() const {
2250 switch (getArch()) {
2251 case Triple::aarch64:
2252 case Triple::aarch64_32:
2253 case Triple::amdgpu:
2254 case Triple::amdil64:
2255 case Triple::amdil:
2256 case Triple::arm:
2257 case Triple::avr:
2258 case Triple::bpfel:
2259 case Triple::csky:
2260 case Triple::dxil:
2261 case Triple::hexagon:
2262 case Triple::hsail64:
2263 case Triple::hsail:
2264 case Triple::kalimba:
2265 case Triple::loongarch32:
2266 case Triple::loongarch64:
2267 case Triple::mips64el:
2268 case Triple::mipsel:
2269 case Triple::msp430:
2270 case Triple::nvptx64:
2271 case Triple::nvptx:
2272 case Triple::ppcle:
2273 case Triple::ppc64le:
2274 case Triple::r600:
2275 case Triple::renderscript32:
2276 case Triple::renderscript64:
2277 case Triple::riscv32:
2278 case Triple::riscv64:
2279 case Triple::shave:
2280 case Triple::sparcel:
2281 case Triple::spir64:
2282 case Triple::spir:
2283 case Triple::spirv:
2284 case Triple::spirv32:
2285 case Triple::spirv64:
2286 case Triple::tcele:
2287 case Triple::tcele64:
2288 case Triple::thumb:
2289 case Triple::ve:
2290 case Triple::wasm32:
2291 case Triple::wasm64:
2292 case Triple::x86:
2293 case Triple::x86_64:
2294 case Triple::xcore:
2295 case Triple::xtensa:
2296 return true;
2297 default:
2298 return false;
2299 }
2300}
2301
2302unsigned Triple::getDefaultWCharSize() const {
2303 if (getArch() == Triple::xcore)
2304 return 1;
2305 if (isOSWindowsOrUEFI() || isPS())
2306 return 2;
2307 if (isOSAIX() && isArch32Bit())
2308 return 2;
2309 return 4;
2310}
2311
2312bool Triple::isCompatibleWith(const Triple &Other) const {
2313 // On MinGW, C code is usually built with a "w64" vendor, while Rust
2314 // often uses a "pc" vendor.
2315 bool IgnoreVendor = isWindowsGNUEnvironment();
2316
2317 // ARM and Thumb triples are compatible, if subarch, vendor and OS match.
2318 if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) ||
2319 (getArch() == Triple::arm && Other.getArch() == Triple::thumb) ||
2320 (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) ||
2321 (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) {
2322 if (getVendor() == Triple::Apple)
2323 return getSubArch() == Other.getSubArch() &&
2324 getVendor() == Other.getVendor() && getOS() == Other.getOS();
2325 else
2326 return getSubArch() == Other.getSubArch() &&
2327 (getVendor() == Other.getVendor() || IgnoreVendor) &&
2328 getOS() == Other.getOS() &&
2329 getEnvironment() == Other.getEnvironment() &&
2330 getObjectFormat() == Other.getObjectFormat();
2331 }
2332
2333 if (getArch() == Triple::amdgpu && Other.getArch() == Triple::amdgpu) {
2334 if (getOS() != Other.getOS() || getVendor() != Other.getVendor() ||
2335 getEnvironment() != Other.getEnvironment() ||
2336 getObjectFormat() != Other.getObjectFormat())
2337 return false;
2338 return AMDGPU::isSubArchCompatible(A: *this, B: Other);
2339 }
2340
2341 // If vendor is apple, ignore the version number (the environment field)
2342 // and the object format.
2343 if (getVendor() == Triple::Apple)
2344 return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
2345 (getVendor() == Other.getVendor() || IgnoreVendor) &&
2346 getOS() == Other.getOS();
2347
2348 return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
2349 (getVendor() == Other.getVendor() || IgnoreVendor) &&
2350 getOS() == Other.getOS() &&
2351 getEnvironment() == Other.getEnvironment() &&
2352 getObjectFormat() == Other.getObjectFormat();
2353}
2354
2355std::string Triple::merge(const Triple &Other) const {
2356 // If vendor is apple, pick the triple with the larger version number.
2357 if (getVendor() == Triple::Apple && Other.isOSVersionLT(Other: *this))
2358 return str();
2359
2360 if (isAMDGCN() && Other.isAMDGCN() && getOS() == Other.getOS() &&
2361 getVendor() == Other.getVendor())
2362 return AMDGPU::mergeSubArch(A: *this, B: Other);
2363
2364 return Other.str();
2365}
2366
2367bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor,
2368 unsigned Micro) const {
2369 assert(isMacOSX() && "Not an OS X triple!");
2370
2371 // If this is OS X, expect a sane version number.
2372 if (getOS() == Triple::MacOSX)
2373 return isOSVersionLT(Major, Minor, Micro);
2374
2375 // Otherwise, compare to the "Darwin" number.
2376 if (Major == 10)
2377 return isOSVersionLT(Major: Minor + 4, Minor: Micro, Micro: 0);
2378 assert(Major >= 11 && "Unexpected major version");
2379 if (Major < 25)
2380 return isOSVersionLT(Major: Major - 11 + 20, Minor, Micro);
2381 return isOSVersionLT(Major: Major + 1, Minor, Micro);
2382}
2383
2384VersionTuple Triple::getMinimumSupportedOSVersion() const {
2385 if (getVendor() != Triple::Apple || getArch() != Triple::aarch64)
2386 return VersionTuple();
2387 switch (getOS()) {
2388 case Triple::MacOSX:
2389 // ARM64 slice is supported starting from macOS 11.0+.
2390 return VersionTuple(11, 0, 0);
2391 case Triple::IOS:
2392 // ARM64 slice is supported starting from Mac Catalyst 14 (macOS 11).
2393 // ARM64 simulators are supported for iOS 14+.
2394 if (isMacCatalystEnvironment() || isSimulatorEnvironment())
2395 return VersionTuple(14, 0, 0);
2396 // ARM64e slice is supported starting from iOS 14.
2397 if (isArm64e())
2398 return VersionTuple(14, 0, 0);
2399 break;
2400 case Triple::TvOS:
2401 // ARM64 simulators are supported for tvOS 14+.
2402 if (isSimulatorEnvironment())
2403 return VersionTuple(14, 0, 0);
2404 break;
2405 case Triple::WatchOS:
2406 // ARM64 simulators are supported for watchOS 7+.
2407 if (isSimulatorEnvironment())
2408 return VersionTuple(7, 0, 0);
2409 // ARM64/ARM64e slices are supported starting from watchOS 26.
2410 // ARM64_32 is older though.
2411 assert(getArch() != Triple::aarch64_32);
2412 return VersionTuple(26, 0, 0);
2413 case Triple::DriverKit:
2414 return VersionTuple(20, 0, 0);
2415 default:
2416 break;
2417 }
2418 return VersionTuple();
2419}
2420
2421VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind,
2422 const VersionTuple &Version,
2423 bool IsInValidRange) {
2424 const unsigned MacOSRangeBump = 10;
2425 const unsigned IOSRangeBump = 7;
2426 const unsigned XROSRangeBump = 23;
2427 const unsigned WatchOSRangeBump = 14;
2428 switch (OSKind) {
2429 case MacOSX: {
2430 // macOS 10.16 is canonicalized to macOS 11.
2431 if (Version == VersionTuple(10, 16))
2432 return VersionTuple(11, 0);
2433 // macOS 16 is canonicalized to macOS 26.
2434 if (Version == VersionTuple(16, 0))
2435 return VersionTuple(26, 0);
2436 if (!IsInValidRange)
2437 return Version.withMajorReplaced(NewMajor: Version.getMajor() + MacOSRangeBump);
2438 break;
2439 }
2440 case IOS:
2441 case TvOS: {
2442 // Both iOS & tvOS 19.0 canonicalize to 26.
2443 if (Version == VersionTuple(19, 0))
2444 return VersionTuple(26, 0);
2445 if (!IsInValidRange)
2446 return Version.withMajorReplaced(NewMajor: Version.getMajor() + IOSRangeBump);
2447 break;
2448 }
2449 case XROS: {
2450 // visionOS3 is canonicalized to 26.
2451 if (Version == VersionTuple(3, 0))
2452 return VersionTuple(26, 0);
2453 if (!IsInValidRange)
2454 return Version.withMajorReplaced(NewMajor: Version.getMajor() + XROSRangeBump);
2455 break;
2456 }
2457 case WatchOS: {
2458 // watchOS 12 is canonicalized to 26.
2459 if (Version == VersionTuple(12, 0))
2460 return VersionTuple(26, 0);
2461 if (!IsInValidRange)
2462 return Version.withMajorReplaced(NewMajor: Version.getMajor() + WatchOSRangeBump);
2463 break;
2464 }
2465 case DriverKit: {
2466 // DriverKit26 is canonicalized to 27.
2467 if (Version.getMajor() == 26U)
2468 return Version.withMajorReplaced(NewMajor: 27);
2469 break;
2470 }
2471 default:
2472 return Version;
2473 }
2474
2475 return Version;
2476}
2477
2478bool Triple::isValidVersionForOS(OSType OSKind, const VersionTuple &Version) {
2479 /// This constant is used to capture gaps in versioning.
2480 const VersionTuple CommonVersion(26);
2481 auto IsValid = [&](const VersionTuple &StartingVersion) {
2482 return !((Version > StartingVersion) && (Version < CommonVersion));
2483 };
2484 switch (OSKind) {
2485 case WatchOS: {
2486 const VersionTuple StartingWatchOS(12);
2487 return IsValid(StartingWatchOS);
2488 }
2489 case IOS:
2490 case TvOS: {
2491 const VersionTuple StartingIOS(19);
2492 return IsValid(StartingIOS);
2493 }
2494 case MacOSX: {
2495 const VersionTuple StartingMacOS(16);
2496 return IsValid(StartingMacOS);
2497 }
2498 case XROS: {
2499 const VersionTuple StartingXROS(3);
2500 return IsValid(StartingXROS);
2501 }
2502 default:
2503 return true;
2504 }
2505
2506 llvm_unreachable("unexpected or invalid os version");
2507}
2508
2509ExceptionHandling Triple::getDefaultExceptionHandling() const {
2510 if (isOSBinFormatCOFF()) {
2511 if (getArch() == Triple::x86 &&
2512 (isOSCygMing() || isWindowsItaniumEnvironment()))
2513 return ExceptionHandling::DwarfCFI;
2514 return ExceptionHandling::WinEH;
2515 }
2516
2517 if (isOSBinFormatXCOFF())
2518 return ExceptionHandling::AIX;
2519 if (isOSBinFormatGOFF())
2520 return ExceptionHandling::ZOS;
2521
2522 if (isARM() || isThumb()) {
2523 if (isOSBinFormatELF()) {
2524 return getOS() == Triple::NetBSD ? ExceptionHandling::DwarfCFI
2525 : ExceptionHandling::ARM;
2526 }
2527
2528 return isOSDarwin() && !isWatchABI() ? ExceptionHandling::SjLj
2529 : ExceptionHandling::DwarfCFI;
2530 }
2531
2532 if (isAArch64() || isX86() || isPPC() || isMIPS() || isSPARC() || isBPF() ||
2533 isRISCV() || isLoongArch())
2534 return ExceptionHandling::DwarfCFI;
2535
2536 switch (getArch()) {
2537 case Triple::arc:
2538 case Triple::csky:
2539 case Triple::hexagon:
2540 case Triple::lanai:
2541 case Triple::m68k:
2542 case Triple::msp430:
2543 case Triple::systemz:
2544 case Triple::xcore:
2545 case Triple::xtensa:
2546 return ExceptionHandling::DwarfCFI;
2547 default:
2548 break;
2549 }
2550
2551 // Explicitly none targets.
2552 if (isWasm() || isAMDGPU() || isNVPTX() || isSPIROrSPIRV())
2553 return ExceptionHandling::None;
2554
2555 // Default to none.
2556 return ExceptionHandling::None;
2557}
2558
2559// HLSL triple environment orders are relied on in the front end
2560static_assert(Triple::Vertex - Triple::Pixel == 1,
2561 "incorrect HLSL stage order");
2562static_assert(Triple::Geometry - Triple::Pixel == 2,
2563 "incorrect HLSL stage order");
2564static_assert(Triple::Hull - Triple::Pixel == 3, "incorrect HLSL stage order");
2565static_assert(Triple::Domain - Triple::Pixel == 4,
2566 "incorrect HLSL stage order");
2567static_assert(Triple::Compute - Triple::Pixel == 5,
2568 "incorrect HLSL stage order");
2569static_assert(Triple::Library - Triple::Pixel == 6,
2570 "incorrect HLSL stage order");
2571static_assert(Triple::RayGeneration - Triple::Pixel == 7,
2572 "incorrect HLSL stage order");
2573static_assert(Triple::Intersection - Triple::Pixel == 8,
2574 "incorrect HLSL stage order");
2575static_assert(Triple::AnyHit - Triple::Pixel == 9,
2576 "incorrect HLSL stage order");
2577static_assert(Triple::ClosestHit - Triple::Pixel == 10,
2578 "incorrect HLSL stage order");
2579static_assert(Triple::Miss - Triple::Pixel == 11, "incorrect HLSL stage order");
2580static_assert(Triple::Callable - Triple::Pixel == 12,
2581 "incorrect HLSL stage order");
2582static_assert(Triple::Mesh - Triple::Pixel == 13, "incorrect HLSL stage order");
2583static_assert(Triple::Amplification - Triple::Pixel == 14,
2584 "incorrect HLSL stage order");
2585