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