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