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(const Twine &Str)
1022 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
1023 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
1024 ObjectFormat(UnknownObjectFormat) {
1025 // Do minimal parsing by hand here.
1026 SmallVector<StringRef, 4> Components;
1027 StringRef(Data).split(A&: Components, Separator: '-', /*MaxSplit*/ 3);
1028 if (Components.size() > 0) {
1029 Arch = parseArch(ArchName: Components[0]);
1030 SubArch = parseSubArch(SubArchName: Components[0]);
1031 if (Components.size() > 1) {
1032 Vendor = parseVendor(VendorName: Components[1]);
1033 if (Components.size() > 2) {
1034 OS = parseOS(OSName: Components[2]);
1035 if (Components.size() > 3) {
1036 Environment = parseEnvironment(EnvironmentName: Components[3]);
1037 ObjectFormat = parseFormat(EnvironmentName: Components[3]);
1038 }
1039 }
1040 } else {
1041 Environment =
1042 StringSwitch<Triple::EnvironmentType>(Components[0])
1043 .StartsWith(S: "mipsn32", Value: Triple::GNUABIN32)
1044 .StartsWith(S: "mips64", Value: Triple::GNUABI64)
1045 .StartsWith(S: "mipsisa64", Value: Triple::GNUABI64)
1046 .StartsWith(S: "mipsisa32", Value: Triple::GNU)
1047 .Cases(S0: "mips", S1: "mipsel", S2: "mipsr6", S3: "mipsr6el", Value: Triple::GNU)
1048 .Default(Value: UnknownEnvironment);
1049 }
1050 }
1051 if (ObjectFormat == UnknownObjectFormat)
1052 ObjectFormat = getDefaultFormat(T: *this);
1053}
1054
1055/// Construct a triple from string representations of the architecture,
1056/// vendor, and OS.
1057///
1058/// This joins each argument into a canonical string representation and parses
1059/// them into enum members. It leaves the environment unknown and omits it from
1060/// the string representation.
1061Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
1062 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
1063 Arch(parseArch(ArchName: ArchStr.str())),
1064 SubArch(parseSubArch(SubArchName: ArchStr.str())),
1065 Vendor(parseVendor(VendorName: VendorStr.str())),
1066 OS(parseOS(OSName: OSStr.str())),
1067 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
1068 ObjectFormat = getDefaultFormat(T: *this);
1069}
1070
1071/// Construct a triple from string representations of the architecture,
1072/// vendor, OS, and environment.
1073///
1074/// This joins each argument into a canonical string representation and parses
1075/// them into enum members.
1076Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
1077 const Twine &EnvironmentStr)
1078 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
1079 EnvironmentStr).str()),
1080 Arch(parseArch(ArchName: ArchStr.str())),
1081 SubArch(parseSubArch(SubArchName: ArchStr.str())),
1082 Vendor(parseVendor(VendorName: VendorStr.str())),
1083 OS(parseOS(OSName: OSStr.str())),
1084 Environment(parseEnvironment(EnvironmentName: EnvironmentStr.str())),
1085 ObjectFormat(parseFormat(EnvironmentName: EnvironmentStr.str())) {
1086 if (ObjectFormat == Triple::UnknownObjectFormat)
1087 ObjectFormat = getDefaultFormat(T: *this);
1088}
1089
1090static VersionTuple parseVersionFromName(StringRef Name);
1091
1092static StringRef getDXILArchNameFromShaderModel(StringRef ShaderModelStr) {
1093 VersionTuple Ver =
1094 parseVersionFromName(Name: ShaderModelStr.drop_front(N: strlen(s: "shadermodel")));
1095 // Default DXIL minor version when Shader Model version is anything other
1096 // than 6.[0...8] or 6.x (which translates to latest current SM version)
1097 const unsigned SMMajor = 6;
1098 if (!Ver.empty()) {
1099 if (Ver.getMajor() == SMMajor) {
1100 if (std::optional<unsigned> SMMinor = Ver.getMinor()) {
1101 switch (*SMMinor) {
1102 case 0:
1103 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_0);
1104 case 1:
1105 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_1);
1106 case 2:
1107 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_2);
1108 case 3:
1109 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_3);
1110 case 4:
1111 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_4);
1112 case 5:
1113 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_5);
1114 case 6:
1115 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_6);
1116 case 7:
1117 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_7);
1118 case 8:
1119 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_8);
1120 default:
1121 report_fatal_error(reason: "Unsupported Shader Model version", gen_crash_diag: false);
1122 }
1123 }
1124 }
1125 } else {
1126 // Special case: DXIL minor version is set to LatestCurrentDXILMinor for
1127 // shadermodel6.x is
1128 if (ShaderModelStr == "shadermodel6.x") {
1129 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::LatestDXILSubArch);
1130 }
1131 }
1132 // DXIL version corresponding to Shader Model version other than 6.Minor
1133 // is 1.0
1134 return Triple::getArchName(Kind: Triple::dxil, SubArch: Triple::DXILSubArch_v1_0);
1135}
1136
1137std::string Triple::normalize(StringRef Str, CanonicalForm Form) {
1138 bool IsMinGW32 = false;
1139 bool IsCygwin = false;
1140
1141 // Parse into components.
1142 SmallVector<StringRef, 4> Components;
1143 Str.split(A&: Components, Separator: '-');
1144
1145 // If the first component corresponds to a known architecture, preferentially
1146 // use it for the architecture. If the second component corresponds to a
1147 // known vendor, preferentially use it for the vendor, etc. This avoids silly
1148 // component movement when a component parses as (eg) both a valid arch and a
1149 // valid os.
1150 ArchType Arch = UnknownArch;
1151 if (Components.size() > 0)
1152 Arch = parseArch(ArchName: Components[0]);
1153 VendorType Vendor = UnknownVendor;
1154 if (Components.size() > 1)
1155 Vendor = parseVendor(VendorName: Components[1]);
1156 OSType OS = UnknownOS;
1157 if (Components.size() > 2) {
1158 OS = parseOS(OSName: Components[2]);
1159 IsCygwin = Components[2].starts_with(Prefix: "cygwin") ||
1160 Components[2].starts_with(Prefix: "msys");
1161 IsMinGW32 = Components[2].starts_with(Prefix: "mingw");
1162 }
1163 EnvironmentType Environment = UnknownEnvironment;
1164 if (Components.size() > 3)
1165 Environment = parseEnvironment(EnvironmentName: Components[3]);
1166 ObjectFormatType ObjectFormat = UnknownObjectFormat;
1167 if (Components.size() > 4)
1168 ObjectFormat = parseFormat(EnvironmentName: Components[4]);
1169
1170 // Note which components are already in their final position. These will not
1171 // be moved.
1172 bool Found[4];
1173 Found[0] = Arch != UnknownArch;
1174 Found[1] = Vendor != UnknownVendor;
1175 Found[2] = OS != UnknownOS;
1176 Found[3] = Environment != UnknownEnvironment;
1177
1178 // If they are not there already, permute the components into their canonical
1179 // positions by seeing if they parse as a valid architecture, and if so moving
1180 // the component to the architecture position etc.
1181 for (unsigned Pos = 0; Pos != std::size(Found); ++Pos) {
1182 if (Found[Pos])
1183 continue; // Already in the canonical position.
1184
1185 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
1186 // Do not reparse any components that already matched.
1187 if (Idx < std::size(Found) && Found[Idx])
1188 continue;
1189
1190 // Does this component parse as valid for the target position?
1191 bool Valid = false;
1192 StringRef Comp = Components[Idx];
1193 switch (Pos) {
1194 default: llvm_unreachable("unexpected component type!");
1195 case 0:
1196 Arch = parseArch(ArchName: Comp);
1197 Valid = Arch != UnknownArch;
1198 break;
1199 case 1:
1200 Vendor = parseVendor(VendorName: Comp);
1201 Valid = Vendor != UnknownVendor;
1202 break;
1203 case 2:
1204 OS = parseOS(OSName: Comp);
1205 IsCygwin = Comp.starts_with(Prefix: "cygwin") || Comp.starts_with(Prefix: "msys");
1206 IsMinGW32 = Comp.starts_with(Prefix: "mingw");
1207 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
1208 break;
1209 case 3:
1210 Environment = parseEnvironment(EnvironmentName: Comp);
1211 Valid = Environment != UnknownEnvironment;
1212 if (!Valid) {
1213 ObjectFormat = parseFormat(EnvironmentName: Comp);
1214 Valid = ObjectFormat != UnknownObjectFormat;
1215 }
1216 break;
1217 }
1218 if (!Valid)
1219 continue; // Nope, try the next component.
1220
1221 // Move the component to the target position, pushing any non-fixed
1222 // components that are in the way to the right. This tends to give
1223 // good results in the common cases of a forgotten vendor component
1224 // or a wrongly positioned environment.
1225 if (Pos < Idx) {
1226 // Insert left, pushing the existing components to the right. For
1227 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
1228 StringRef CurrentComponent(""); // The empty component.
1229 // Replace the component we are moving with an empty component.
1230 std::swap(a&: CurrentComponent, b&: Components[Idx]);
1231 // Insert the component being moved at Pos, displacing any existing
1232 // components to the right.
1233 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
1234 // Skip over any fixed components.
1235 while (i < std::size(Found) && Found[i])
1236 ++i;
1237 // Place the component at the new position, getting the component
1238 // that was at this position - it will be moved right.
1239 std::swap(a&: CurrentComponent, b&: Components[i]);
1240 }
1241 } else if (Pos > Idx) {
1242 // Push right by inserting empty components until the component at Idx
1243 // reaches the target position Pos. For example, pc-a -> -pc-a when
1244 // moving pc to the second position.
1245 do {
1246 // Insert one empty component at Idx.
1247 StringRef CurrentComponent(""); // The empty component.
1248 for (unsigned i = Idx; i < Components.size();) {
1249 // Place the component at the new position, getting the component
1250 // that was at this position - it will be moved right.
1251 std::swap(a&: CurrentComponent, b&: Components[i]);
1252 // If it was placed on top of an empty component then we are done.
1253 if (CurrentComponent.empty())
1254 break;
1255 // Advance to the next component, skipping any fixed components.
1256 while (++i < std::size(Found) && Found[i])
1257 ;
1258 }
1259 // The last component was pushed off the end - append it.
1260 if (!CurrentComponent.empty())
1261 Components.push_back(Elt: CurrentComponent);
1262
1263 // Advance Idx to the component's new position.
1264 while (++Idx < std::size(Found) && Found[Idx])
1265 ;
1266 } while (Idx < Pos); // Add more until the final position is reached.
1267 }
1268 assert(Pos < Components.size() && Components[Pos] == Comp &&
1269 "Component moved wrong!");
1270 Found[Pos] = true;
1271 break;
1272 }
1273 }
1274
1275 // If "none" is in the middle component in a three-component triple, treat it
1276 // as the OS (Components[2]) instead of the vendor (Components[1]).
1277 if (Found[0] && !Found[1] && !Found[2] && Found[3] &&
1278 Components[1] == "none" && Components[2].empty())
1279 std::swap(a&: Components[1], b&: Components[2]);
1280
1281 // Replace empty components with "unknown" value.
1282 for (StringRef &C : Components)
1283 if (C.empty())
1284 C = "unknown";
1285
1286 // Special case logic goes here. At this point Arch, Vendor and OS have the
1287 // correct values for the computed components.
1288 std::string NormalizedEnvironment;
1289 if (Environment == Triple::Android &&
1290 Components[3].starts_with(Prefix: "androideabi")) {
1291 StringRef AndroidVersion = Components[3].drop_front(N: strlen(s: "androideabi"));
1292 if (AndroidVersion.empty()) {
1293 Components[3] = "android";
1294 } else {
1295 NormalizedEnvironment = Twine("android", AndroidVersion).str();
1296 Components[3] = NormalizedEnvironment;
1297 }
1298 }
1299
1300 // SUSE uses "gnueabi" to mean "gnueabihf"
1301 if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI)
1302 Components[3] = "gnueabihf";
1303
1304 if (OS == Triple::Win32) {
1305 Components.resize(N: 4);
1306 Components[2] = "windows";
1307 if (Environment == UnknownEnvironment) {
1308 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
1309 Components[3] = "msvc";
1310 else
1311 Components[3] = getObjectFormatTypeName(Kind: ObjectFormat);
1312 }
1313 } else if (IsMinGW32) {
1314 Components.resize(N: 4);
1315 Components[2] = "windows";
1316 Components[3] = "gnu";
1317 } else if (IsCygwin) {
1318 Components.resize(N: 4);
1319 Components[2] = "windows";
1320 Components[3] = "cygnus";
1321 }
1322 if (IsMinGW32 || IsCygwin ||
1323 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
1324 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
1325 Components.resize(N: 5);
1326 Components[4] = getObjectFormatTypeName(Kind: ObjectFormat);
1327 }
1328 }
1329
1330 // Normalize DXIL triple if it does not include DXIL version number.
1331 // Determine DXIL version number using the minor version number of Shader
1332 // Model version specified in target triple, if any. Prior to decoupling DXIL
1333 // version numbering from that of Shader Model DXIL version 1.Y corresponds to
1334 // SM 6.Y. E.g., dxilv1.Y-unknown-shadermodelX.Y-hull
1335 if (Components[0] == "dxil") {
1336 if (Components.size() > 4) {
1337 Components.resize(N: 4);
1338 }
1339 // Add DXIL version only if shadermodel is specified in the triple
1340 if (OS == Triple::ShaderModel) {
1341 Components[0] = getDXILArchNameFromShaderModel(ShaderModelStr: Components[2]);
1342 }
1343 }
1344
1345 // Canonicalize the components if necessary.
1346 switch (Form) {
1347 case CanonicalForm::ANY:
1348 break;
1349 case CanonicalForm::THREE_IDENT:
1350 case CanonicalForm::FOUR_IDENT:
1351 case CanonicalForm::FIVE_IDENT: {
1352 Components.resize(N: static_cast<unsigned>(Form), NV: "unknown");
1353 break;
1354 }
1355 }
1356
1357 // Stick the corrected components back together to form the normalized string.
1358 return join(R&: Components, Separator: "-");
1359}
1360
1361StringRef Triple::getArchName() const {
1362 return StringRef(Data).split(Separator: '-').first; // Isolate first component
1363}
1364
1365StringRef Triple::getVendorName() const {
1366 StringRef Tmp = StringRef(Data).split(Separator: '-').second; // Strip first component
1367 return Tmp.split(Separator: '-').first; // Isolate second component
1368}
1369
1370StringRef Triple::getOSName() const {
1371 StringRef Tmp = StringRef(Data).split(Separator: '-').second; // Strip first component
1372 Tmp = Tmp.split(Separator: '-').second; // Strip second component
1373 return Tmp.split(Separator: '-').first; // Isolate third component
1374}
1375
1376StringRef Triple::getEnvironmentName() const {
1377 StringRef Tmp = StringRef(Data).split(Separator: '-').second; // Strip first component
1378 Tmp = Tmp.split(Separator: '-').second; // Strip second component
1379 return Tmp.split(Separator: '-').second; // Strip third component
1380}
1381
1382StringRef Triple::getOSAndEnvironmentName() const {
1383 StringRef Tmp = StringRef(Data).split(Separator: '-').second; // Strip first component
1384 return Tmp.split(Separator: '-').second; // Strip second component
1385}
1386
1387static VersionTuple parseVersionFromName(StringRef Name) {
1388 VersionTuple Version;
1389 Version.tryParse(string: Name);
1390 return Version.withoutBuild();
1391}
1392
1393VersionTuple Triple::getEnvironmentVersion() const {
1394 return parseVersionFromName(Name: getEnvironmentVersionString());
1395}
1396
1397StringRef Triple::getEnvironmentVersionString() const {
1398 StringRef EnvironmentName = getEnvironmentName();
1399
1400 // none is a valid environment type - it basically amounts to a freestanding
1401 // environment.
1402 if (EnvironmentName == "none")
1403 return "";
1404
1405 StringRef EnvironmentTypeName = getEnvironmentTypeName(Kind: getEnvironment());
1406 EnvironmentName.consume_front(Prefix: EnvironmentTypeName);
1407
1408 if (EnvironmentName.contains(Other: "-")) {
1409 // -obj is the suffix
1410 if (getObjectFormat() != Triple::UnknownObjectFormat) {
1411 StringRef ObjectFormatTypeName =
1412 getObjectFormatTypeName(Kind: getObjectFormat());
1413 const std::string tmp = (Twine("-") + ObjectFormatTypeName).str();
1414 EnvironmentName.consume_back(Suffix: tmp);
1415 }
1416 }
1417 return EnvironmentName;
1418}
1419
1420VersionTuple Triple::getOSVersion() const {
1421 StringRef OSName = getOSName();
1422 // Assume that the OS portion of the triple starts with the canonical name.
1423 StringRef OSTypeName = getOSTypeName(Kind: getOS());
1424 if (OSName.starts_with(Prefix: OSTypeName))
1425 OSName = OSName.substr(Start: OSTypeName.size());
1426 else if (getOS() == MacOSX)
1427 OSName.consume_front(Prefix: "macos");
1428 else if (OSName.starts_with(Prefix: "visionos"))
1429 OSName.consume_front(Prefix: "visionos");
1430
1431 return parseVersionFromName(Name: OSName);
1432}
1433
1434bool Triple::getMacOSXVersion(VersionTuple &Version) const {
1435 Version = getOSVersion();
1436
1437 switch (getOS()) {
1438 default: llvm_unreachable("unexpected OS for Darwin triple");
1439 case Darwin:
1440 // Default to darwin8, i.e., MacOSX 10.4.
1441 if (Version.getMajor() == 0)
1442 Version = VersionTuple(8);
1443 // Darwin version numbers are skewed from OS X versions.
1444 if (Version.getMajor() < 4) {
1445 return false;
1446 }
1447 if (Version.getMajor() <= 19) {
1448 Version = VersionTuple(10, Version.getMajor() - 4);
1449 } else if (Version.getMajor() < 25) {
1450 // darwin20-24 corresponds to macOS 11-15.
1451 Version = VersionTuple(11 + Version.getMajor() - 20);
1452 } else {
1453 // darwin25 corresponds with macOS26+.
1454 Version = VersionTuple(Version.getMajor() + 1);
1455 }
1456 break;
1457 case MacOSX:
1458 // Default to 10.4.
1459 if (Version.getMajor() == 0) {
1460 Version = VersionTuple(10, 4);
1461 } else if (Version.getMajor() < 10) {
1462 return false;
1463 }
1464 break;
1465 case IOS:
1466 case TvOS:
1467 case WatchOS:
1468 // Ignore the version from the triple. This is only handled because the
1469 // the clang driver combines OS X and IOS support into a common Darwin
1470 // toolchain that wants to know the OS X version number even when targeting
1471 // IOS.
1472 Version = VersionTuple(10, 4);
1473 break;
1474 case XROS:
1475 llvm_unreachable("OSX version isn't relevant for xrOS");
1476 case DriverKit:
1477 llvm_unreachable("OSX version isn't relevant for DriverKit");
1478 }
1479 return true;
1480}
1481
1482VersionTuple Triple::getiOSVersion() const {
1483 switch (getOS()) {
1484 default: llvm_unreachable("unexpected OS for Darwin triple");
1485 case Darwin:
1486 case MacOSX:
1487 // Ignore the version from the triple. This is only handled because the
1488 // the clang driver combines OS X and IOS support into a common Darwin
1489 // toolchain that wants to know the iOS version number even when targeting
1490 // OS X.
1491 return VersionTuple(5);
1492 case IOS:
1493 case TvOS: {
1494 VersionTuple Version = getOSVersion();
1495 // Default to 5.0 (or 7.0 for arm64).
1496 if (Version.getMajor() == 0)
1497 return (getArch() == aarch64) ? VersionTuple(7) : VersionTuple(5);
1498 if (Version.getMajor() == 19)
1499 // tvOS 19 corresponds to ios26.
1500 return VersionTuple(26);
1501 return getCanonicalVersionForOS(OSKind: OSType::IOS, Version,
1502 IsInValidRange: isValidVersionForOS(OSKind: OSType::IOS, Version));
1503 }
1504 case XROS: {
1505 VersionTuple Version = getOSVersion();
1506 // xrOS 1 is aligned with iOS 17.
1507 if (Version.getMajor() < 3)
1508 return Version.withMajorReplaced(NewMajor: Version.getMajor() + 16);
1509 // visionOS 3 corresponds to ios 26+.
1510 if (Version.getMajor() == 3)
1511 return VersionTuple(26);
1512 return getCanonicalVersionForOS(OSKind: OSType::XROS, Version,
1513 IsInValidRange: isValidVersionForOS(OSKind: OSType::XROS, Version));
1514 }
1515 case WatchOS: {
1516 VersionTuple Version = getOSVersion();
1517 // watchOS 12 corresponds to ios 26.
1518 if (Version.getMajor() == 12)
1519 return VersionTuple(26);
1520 return getCanonicalVersionForOS(
1521 OSKind: OSType::WatchOS, Version,
1522 IsInValidRange: isValidVersionForOS(OSKind: OSType::WatchOS, Version));
1523 }
1524 case BridgeOS:
1525 llvm_unreachable("conflicting triple info");
1526 case DriverKit:
1527 llvm_unreachable("DriverKit doesn't have an iOS version");
1528 }
1529}
1530
1531VersionTuple Triple::getWatchOSVersion() const {
1532 switch (getOS()) {
1533 default: llvm_unreachable("unexpected OS for Darwin triple");
1534 case Darwin:
1535 case MacOSX:
1536 // Ignore the version from the triple. This is only handled because the
1537 // the clang driver combines OS X and IOS support into a common Darwin
1538 // toolchain that wants to know the iOS version number even when targeting
1539 // OS X.
1540 return VersionTuple(2);
1541 case WatchOS: {
1542 VersionTuple Version = getOSVersion();
1543 if (Version.getMajor() == 0)
1544 return VersionTuple(2);
1545 return Version;
1546 }
1547 case IOS:
1548 llvm_unreachable("conflicting triple info");
1549 case XROS:
1550 llvm_unreachable("watchOS version isn't relevant for xrOS");
1551 case DriverKit:
1552 llvm_unreachable("DriverKit doesn't have a WatchOS version");
1553 }
1554}
1555
1556VersionTuple Triple::getDriverKitVersion() const {
1557 switch (getOS()) {
1558 default:
1559 llvm_unreachable("unexpected OS for Darwin triple");
1560 case DriverKit:
1561 VersionTuple Version = getOSVersion();
1562 if (Version.getMajor() == 0)
1563 return Version.withMajorReplaced(NewMajor: 19);
1564 return Version;
1565 }
1566}
1567
1568VersionTuple Triple::getVulkanVersion() const {
1569 if (getArch() != spirv || getOS() != Vulkan)
1570 llvm_unreachable("invalid Vulkan SPIR-V triple");
1571
1572 VersionTuple VulkanVersion = getOSVersion();
1573 SubArchType SpirvVersion = getSubArch();
1574
1575 llvm::DenseMap<VersionTuple, SubArchType> ValidVersionMap = {
1576 // Vulkan 1.2 -> SPIR-V 1.5.
1577 {VersionTuple(1, 2), SPIRVSubArch_v15},
1578 // Vulkan 1.3 -> SPIR-V 1.6.
1579 {VersionTuple(1, 3), SPIRVSubArch_v16}};
1580
1581 // If Vulkan version is unset, default to 1.2.
1582 if (VulkanVersion == VersionTuple(0))
1583 VulkanVersion = VersionTuple(1, 2);
1584
1585 if (ValidVersionMap.contains(Val: VulkanVersion) &&
1586 (ValidVersionMap.lookup(Val: VulkanVersion) == SpirvVersion ||
1587 SpirvVersion == NoSubArch))
1588 return VulkanVersion;
1589
1590 return VersionTuple(0);
1591}
1592
1593VersionTuple Triple::getDXILVersion() const {
1594 if (getArch() != dxil || getOS() != ShaderModel)
1595 llvm_unreachable("invalid DXIL triple");
1596 StringRef Arch = getArchName();
1597 if (getSubArch() == NoSubArch)
1598 Arch = getDXILArchNameFromShaderModel(ShaderModelStr: getOSName());
1599 Arch.consume_front(Prefix: "dxilv");
1600 VersionTuple DXILVersion = parseVersionFromName(Name: Arch);
1601 // FIXME: validate DXIL version against Shader Model version.
1602 // Tracked by https://github.com/llvm/llvm-project/issues/91388
1603 return DXILVersion;
1604}
1605
1606void Triple::setTriple(const Twine &Str) {
1607 *this = Triple(Str);
1608}
1609
1610void Triple::setArch(ArchType Kind, SubArchType SubArch) {
1611 setArchName(getArchName(Kind, SubArch));
1612}
1613
1614void Triple::setVendor(VendorType Kind) {
1615 setVendorName(getVendorTypeName(Kind));
1616}
1617
1618void Triple::setOS(OSType Kind) {
1619 setOSName(getOSTypeName(Kind));
1620}
1621
1622void Triple::setEnvironment(EnvironmentType Kind) {
1623 if (ObjectFormat == getDefaultFormat(T: *this))
1624 return setEnvironmentName(getEnvironmentTypeName(Kind));
1625
1626 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1627 getObjectFormatTypeName(Kind: ObjectFormat)).str());
1628}
1629
1630void Triple::setObjectFormat(ObjectFormatType Kind) {
1631 if (Environment == UnknownEnvironment)
1632 return setEnvironmentName(getObjectFormatTypeName(Kind));
1633
1634 setEnvironmentName((getEnvironmentTypeName(Kind: Environment) + Twine("-") +
1635 getObjectFormatTypeName(Kind)).str());
1636}
1637
1638void Triple::setArchName(StringRef Str) {
1639 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1640 SmallString<64> Triple;
1641 Triple += Str;
1642 Triple += "-";
1643 Triple += getVendorName();
1644 Triple += "-";
1645 Triple += getOSAndEnvironmentName();
1646 setTriple(Triple);
1647}
1648
1649void Triple::setVendorName(StringRef Str) {
1650 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1651}
1652
1653void Triple::setOSName(StringRef Str) {
1654 if (hasEnvironment())
1655 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1656 "-" + getEnvironmentName());
1657 else
1658 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1659}
1660
1661void Triple::setEnvironmentName(StringRef Str) {
1662 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1663 "-" + Str);
1664}
1665
1666void Triple::setOSAndEnvironmentName(StringRef Str) {
1667 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1668}
1669
1670unsigned Triple::getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1671 switch (Arch) {
1672 case llvm::Triple::UnknownArch:
1673 return 0;
1674
1675 case llvm::Triple::avr:
1676 case llvm::Triple::msp430:
1677 return 16;
1678
1679 case llvm::Triple::aarch64_32:
1680 case llvm::Triple::amdil:
1681 case llvm::Triple::arc:
1682 case llvm::Triple::arm:
1683 case llvm::Triple::armeb:
1684 case llvm::Triple::csky:
1685 case llvm::Triple::dxil:
1686 case llvm::Triple::hexagon:
1687 case llvm::Triple::hsail:
1688 case llvm::Triple::kalimba:
1689 case llvm::Triple::lanai:
1690 case llvm::Triple::loongarch32:
1691 case llvm::Triple::m68k:
1692 case llvm::Triple::mips:
1693 case llvm::Triple::mipsel:
1694 case llvm::Triple::nvptx:
1695 case llvm::Triple::ppc:
1696 case llvm::Triple::ppcle:
1697 case llvm::Triple::r600:
1698 case llvm::Triple::renderscript32:
1699 case llvm::Triple::riscv32:
1700 case llvm::Triple::shave:
1701 case llvm::Triple::sparc:
1702 case llvm::Triple::sparcel:
1703 case llvm::Triple::spir:
1704 case llvm::Triple::spirv32:
1705 case llvm::Triple::tce:
1706 case llvm::Triple::tcele:
1707 case llvm::Triple::thumb:
1708 case llvm::Triple::thumbeb:
1709 case llvm::Triple::wasm32:
1710 case llvm::Triple::x86:
1711 case llvm::Triple::xcore:
1712 case llvm::Triple::xtensa:
1713 return 32;
1714
1715 case llvm::Triple::aarch64:
1716 case llvm::Triple::aarch64_be:
1717 case llvm::Triple::amdgcn:
1718 case llvm::Triple::amdil64:
1719 case llvm::Triple::bpfeb:
1720 case llvm::Triple::bpfel:
1721 case llvm::Triple::hsail64:
1722 case llvm::Triple::loongarch64:
1723 case llvm::Triple::mips64:
1724 case llvm::Triple::mips64el:
1725 case llvm::Triple::nvptx64:
1726 case llvm::Triple::ppc64:
1727 case llvm::Triple::ppc64le:
1728 case llvm::Triple::renderscript64:
1729 case llvm::Triple::riscv64:
1730 case llvm::Triple::sparcv9:
1731 case llvm::Triple::spirv:
1732 case llvm::Triple::spir64:
1733 case llvm::Triple::spirv64:
1734 case llvm::Triple::systemz:
1735 case llvm::Triple::ve:
1736 case llvm::Triple::wasm64:
1737 case llvm::Triple::x86_64:
1738 return 64;
1739 }
1740 llvm_unreachable("Invalid architecture value");
1741}
1742
1743unsigned Triple::getTrampolineSize() const {
1744 switch (getArch()) {
1745 default:
1746 break;
1747 case Triple::ppc:
1748 case Triple::ppcle:
1749 if (isOSLinux())
1750 return 40;
1751 break;
1752 case Triple::ppc64:
1753 case Triple::ppc64le:
1754 if (isOSLinux())
1755 return 48;
1756 break;
1757 case Triple::aarch64:
1758 return 36;
1759 }
1760 return 32;
1761}
1762
1763bool Triple::isArch64Bit() const {
1764 return getArchPointerBitWidth(Arch: getArch()) == 64;
1765}
1766
1767bool Triple::isArch32Bit() const {
1768 return getArchPointerBitWidth(Arch: getArch()) == 32;
1769}
1770
1771bool Triple::isArch16Bit() const {
1772 return getArchPointerBitWidth(Arch: getArch()) == 16;
1773}
1774
1775Triple Triple::get32BitArchVariant() const {
1776 Triple T(*this);
1777 switch (getArch()) {
1778 case Triple::UnknownArch:
1779 case Triple::amdgcn:
1780 case Triple::avr:
1781 case Triple::bpfeb:
1782 case Triple::bpfel:
1783 case Triple::msp430:
1784 case Triple::systemz:
1785 case Triple::ve:
1786 T.setArch(Kind: UnknownArch);
1787 break;
1788
1789 case Triple::aarch64_32:
1790 case Triple::amdil:
1791 case Triple::arc:
1792 case Triple::arm:
1793 case Triple::armeb:
1794 case Triple::csky:
1795 case Triple::dxil:
1796 case Triple::hexagon:
1797 case Triple::hsail:
1798 case Triple::kalimba:
1799 case Triple::lanai:
1800 case Triple::loongarch32:
1801 case Triple::m68k:
1802 case Triple::mips:
1803 case Triple::mipsel:
1804 case Triple::nvptx:
1805 case Triple::ppc:
1806 case Triple::ppcle:
1807 case Triple::r600:
1808 case Triple::renderscript32:
1809 case Triple::riscv32:
1810 case Triple::shave:
1811 case Triple::sparc:
1812 case Triple::sparcel:
1813 case Triple::spir:
1814 case Triple::spirv32:
1815 case Triple::tce:
1816 case Triple::tcele:
1817 case Triple::thumb:
1818 case Triple::thumbeb:
1819 case Triple::wasm32:
1820 case Triple::x86:
1821 case Triple::xcore:
1822 case Triple::xtensa:
1823 // Already 32-bit.
1824 break;
1825
1826 case Triple::aarch64: T.setArch(Kind: Triple::arm); break;
1827 case Triple::aarch64_be: T.setArch(Kind: Triple::armeb); break;
1828 case Triple::amdil64: T.setArch(Kind: Triple::amdil); break;
1829 case Triple::hsail64: T.setArch(Kind: Triple::hsail); break;
1830 case Triple::loongarch64: T.setArch(Kind: Triple::loongarch32); break;
1831 case Triple::mips64:
1832 T.setArch(Kind: Triple::mips, SubArch: getSubArch());
1833 break;
1834 case Triple::mips64el:
1835 T.setArch(Kind: Triple::mipsel, SubArch: getSubArch());
1836 break;
1837 case Triple::nvptx64: T.setArch(Kind: Triple::nvptx); break;
1838 case Triple::ppc64: T.setArch(Kind: Triple::ppc); break;
1839 case Triple::ppc64le: T.setArch(Kind: Triple::ppcle); break;
1840 case Triple::renderscript64: T.setArch(Kind: Triple::renderscript32); break;
1841 case Triple::riscv64: T.setArch(Kind: Triple::riscv32); break;
1842 case Triple::sparcv9: T.setArch(Kind: Triple::sparc); break;
1843 case Triple::spir64: T.setArch(Kind: Triple::spir); break;
1844 case Triple::spirv:
1845 case Triple::spirv64:
1846 T.setArch(Kind: Triple::spirv32, SubArch: getSubArch());
1847 break;
1848 case Triple::wasm64: T.setArch(Kind: Triple::wasm32); break;
1849 case Triple::x86_64: T.setArch(Kind: Triple::x86); break;
1850 }
1851 return T;
1852}
1853
1854Triple Triple::get64BitArchVariant() const {
1855 Triple T(*this);
1856 switch (getArch()) {
1857 case Triple::UnknownArch:
1858 case Triple::arc:
1859 case Triple::avr:
1860 case Triple::csky:
1861 case Triple::dxil:
1862 case Triple::hexagon:
1863 case Triple::kalimba:
1864 case Triple::lanai:
1865 case Triple::m68k:
1866 case Triple::msp430:
1867 case Triple::r600:
1868 case Triple::shave:
1869 case Triple::sparcel:
1870 case Triple::tce:
1871 case Triple::tcele:
1872 case Triple::xcore:
1873 case Triple::xtensa:
1874 T.setArch(Kind: UnknownArch);
1875 break;
1876
1877 case Triple::aarch64:
1878 case Triple::aarch64_be:
1879 case Triple::amdgcn:
1880 case Triple::amdil64:
1881 case Triple::bpfeb:
1882 case Triple::bpfel:
1883 case Triple::hsail64:
1884 case Triple::loongarch64:
1885 case Triple::mips64:
1886 case Triple::mips64el:
1887 case Triple::nvptx64:
1888 case Triple::ppc64:
1889 case Triple::ppc64le:
1890 case Triple::renderscript64:
1891 case Triple::riscv64:
1892 case Triple::sparcv9:
1893 case Triple::spir64:
1894 case Triple::spirv64:
1895 case Triple::systemz:
1896 case Triple::ve:
1897 case Triple::wasm64:
1898 case Triple::x86_64:
1899 // Already 64-bit.
1900 break;
1901
1902 case Triple::aarch64_32: T.setArch(Kind: Triple::aarch64); break;
1903 case Triple::amdil: T.setArch(Kind: Triple::amdil64); break;
1904 case Triple::arm: T.setArch(Kind: Triple::aarch64); break;
1905 case Triple::armeb: T.setArch(Kind: Triple::aarch64_be); break;
1906 case Triple::hsail: T.setArch(Kind: Triple::hsail64); break;
1907 case Triple::loongarch32: T.setArch(Kind: Triple::loongarch64); break;
1908 case Triple::mips:
1909 T.setArch(Kind: Triple::mips64, SubArch: getSubArch());
1910 break;
1911 case Triple::mipsel:
1912 T.setArch(Kind: Triple::mips64el, SubArch: getSubArch());
1913 break;
1914 case Triple::nvptx: T.setArch(Kind: Triple::nvptx64); break;
1915 case Triple::ppc: T.setArch(Kind: Triple::ppc64); break;
1916 case Triple::ppcle: T.setArch(Kind: Triple::ppc64le); break;
1917 case Triple::renderscript32: T.setArch(Kind: Triple::renderscript64); break;
1918 case Triple::riscv32: T.setArch(Kind: Triple::riscv64); break;
1919 case Triple::sparc: T.setArch(Kind: Triple::sparcv9); break;
1920 case Triple::spir: T.setArch(Kind: Triple::spir64); break;
1921 case Triple::spirv:
1922 case Triple::spirv32:
1923 T.setArch(Kind: Triple::spirv64, SubArch: getSubArch());
1924 break;
1925 case Triple::thumb: T.setArch(Kind: Triple::aarch64); break;
1926 case Triple::thumbeb: T.setArch(Kind: Triple::aarch64_be); break;
1927 case Triple::wasm32: T.setArch(Kind: Triple::wasm64); break;
1928 case Triple::x86: T.setArch(Kind: Triple::x86_64); break;
1929 }
1930 return T;
1931}
1932
1933Triple Triple::getBigEndianArchVariant() const {
1934 Triple T(*this);
1935 // Already big endian.
1936 if (!isLittleEndian())
1937 return T;
1938 switch (getArch()) {
1939 case Triple::UnknownArch:
1940 case Triple::amdgcn:
1941 case Triple::amdil64:
1942 case Triple::amdil:
1943 case Triple::avr:
1944 case Triple::dxil:
1945 case Triple::hexagon:
1946 case Triple::hsail64:
1947 case Triple::hsail:
1948 case Triple::kalimba:
1949 case Triple::loongarch32:
1950 case Triple::loongarch64:
1951 case Triple::msp430:
1952 case Triple::nvptx64:
1953 case Triple::nvptx:
1954 case Triple::r600:
1955 case Triple::renderscript32:
1956 case Triple::renderscript64:
1957 case Triple::riscv32:
1958 case Triple::riscv64:
1959 case Triple::shave:
1960 case Triple::spir64:
1961 case Triple::spir:
1962 case Triple::spirv:
1963 case Triple::spirv32:
1964 case Triple::spirv64:
1965 case Triple::wasm32:
1966 case Triple::wasm64:
1967 case Triple::x86:
1968 case Triple::x86_64:
1969 case Triple::xcore:
1970 case Triple::ve:
1971 case Triple::csky:
1972 case Triple::xtensa:
1973
1974 // ARM is intentionally unsupported here, changing the architecture would
1975 // drop any arch suffixes.
1976 case Triple::arm:
1977 case Triple::thumb:
1978 T.setArch(Kind: UnknownArch);
1979 break;
1980
1981 case Triple::aarch64: T.setArch(Kind: Triple::aarch64_be); break;
1982 case Triple::bpfel: T.setArch(Kind: Triple::bpfeb); break;
1983 case Triple::mips64el:
1984 T.setArch(Kind: Triple::mips64, SubArch: getSubArch());
1985 break;
1986 case Triple::mipsel:
1987 T.setArch(Kind: Triple::mips, SubArch: getSubArch());
1988 break;
1989 case Triple::ppcle: T.setArch(Kind: Triple::ppc); break;
1990 case Triple::ppc64le: T.setArch(Kind: Triple::ppc64); break;
1991 case Triple::sparcel: T.setArch(Kind: Triple::sparc); break;
1992 case Triple::tcele: T.setArch(Kind: Triple::tce); break;
1993 default:
1994 llvm_unreachable("getBigEndianArchVariant: unknown triple.");
1995 }
1996 return T;
1997}
1998
1999Triple Triple::getLittleEndianArchVariant() const {
2000 Triple T(*this);
2001 if (isLittleEndian())
2002 return T;
2003
2004 switch (getArch()) {
2005 case Triple::UnknownArch:
2006 case Triple::lanai:
2007 case Triple::sparcv9:
2008 case Triple::systemz:
2009 case Triple::m68k:
2010
2011 // ARM is intentionally unsupported here, changing the architecture would
2012 // drop any arch suffixes.
2013 case Triple::armeb:
2014 case Triple::thumbeb:
2015 T.setArch(Kind: UnknownArch);
2016 break;
2017
2018 case Triple::aarch64_be: T.setArch(Kind: Triple::aarch64); break;
2019 case Triple::bpfeb: T.setArch(Kind: Triple::bpfel); break;
2020 case Triple::mips64:
2021 T.setArch(Kind: Triple::mips64el, SubArch: getSubArch());
2022 break;
2023 case Triple::mips:
2024 T.setArch(Kind: Triple::mipsel, SubArch: getSubArch());
2025 break;
2026 case Triple::ppc: T.setArch(Kind: Triple::ppcle); break;
2027 case Triple::ppc64: T.setArch(Kind: Triple::ppc64le); break;
2028 case Triple::sparc: T.setArch(Kind: Triple::sparcel); break;
2029 case Triple::tce: T.setArch(Kind: Triple::tcele); break;
2030 default:
2031 llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
2032 }
2033 return T;
2034}
2035
2036bool Triple::isLittleEndian() const {
2037 switch (getArch()) {
2038 case Triple::aarch64:
2039 case Triple::aarch64_32:
2040 case Triple::amdgcn:
2041 case Triple::amdil64:
2042 case Triple::amdil:
2043 case Triple::arm:
2044 case Triple::avr:
2045 case Triple::bpfel:
2046 case Triple::csky:
2047 case Triple::dxil:
2048 case Triple::hexagon:
2049 case Triple::hsail64:
2050 case Triple::hsail:
2051 case Triple::kalimba:
2052 case Triple::loongarch32:
2053 case Triple::loongarch64:
2054 case Triple::mips64el:
2055 case Triple::mipsel:
2056 case Triple::msp430:
2057 case Triple::nvptx64:
2058 case Triple::nvptx:
2059 case Triple::ppcle:
2060 case Triple::ppc64le:
2061 case Triple::r600:
2062 case Triple::renderscript32:
2063 case Triple::renderscript64:
2064 case Triple::riscv32:
2065 case Triple::riscv64:
2066 case Triple::shave:
2067 case Triple::sparcel:
2068 case Triple::spir64:
2069 case Triple::spir:
2070 case Triple::spirv:
2071 case Triple::spirv32:
2072 case Triple::spirv64:
2073 case Triple::tcele:
2074 case Triple::thumb:
2075 case Triple::ve:
2076 case Triple::wasm32:
2077 case Triple::wasm64:
2078 case Triple::x86:
2079 case Triple::x86_64:
2080 case Triple::xcore:
2081 case Triple::xtensa:
2082 return true;
2083 default:
2084 return false;
2085 }
2086}
2087
2088bool Triple::isCompatibleWith(const Triple &Other) const {
2089 // On MinGW, C code is usually built with a "w64" vendor, while Rust
2090 // often uses a "pc" vendor.
2091 bool IgnoreVendor = isWindowsGNUEnvironment();
2092
2093 // ARM and Thumb triples are compatible, if subarch, vendor and OS match.
2094 if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) ||
2095 (getArch() == Triple::arm && Other.getArch() == Triple::thumb) ||
2096 (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) ||
2097 (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) {
2098 if (getVendor() == Triple::Apple)
2099 return getSubArch() == Other.getSubArch() &&
2100 getVendor() == Other.getVendor() && getOS() == Other.getOS();
2101 else
2102 return getSubArch() == Other.getSubArch() &&
2103 (getVendor() == Other.getVendor() || IgnoreVendor) &&
2104 getOS() == Other.getOS() &&
2105 getEnvironment() == Other.getEnvironment() &&
2106 getObjectFormat() == Other.getObjectFormat();
2107 }
2108
2109 // If vendor is apple, ignore the version number (the environment field)
2110 // and the object format.
2111 if (getVendor() == Triple::Apple)
2112 return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
2113 (getVendor() == Other.getVendor() || IgnoreVendor) &&
2114 getOS() == Other.getOS();
2115
2116 return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
2117 (getVendor() == Other.getVendor() || IgnoreVendor) &&
2118 getOS() == Other.getOS() &&
2119 getEnvironment() == Other.getEnvironment() &&
2120 getObjectFormat() == Other.getObjectFormat();
2121}
2122
2123std::string Triple::merge(const Triple &Other) const {
2124 // If vendor is apple, pick the triple with the larger version number.
2125 if (getVendor() == Triple::Apple)
2126 if (Other.isOSVersionLT(Other: *this))
2127 return str();
2128
2129 return Other.str();
2130}
2131
2132bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor,
2133 unsigned Micro) const {
2134 assert(isMacOSX() && "Not an OS X triple!");
2135
2136 // If this is OS X, expect a sane version number.
2137 if (getOS() == Triple::MacOSX)
2138 return isOSVersionLT(Major, Minor, Micro);
2139
2140 // Otherwise, compare to the "Darwin" number.
2141 if (Major == 10)
2142 return isOSVersionLT(Major: Minor + 4, Minor: Micro, Micro: 0);
2143 assert(Major >= 11 && "Unexpected major version");
2144 if (Major < 25)
2145 return isOSVersionLT(Major: Major - 11 + 20, Minor, Micro);
2146 return isOSVersionLT(Major: Major + 1, Minor, Micro);
2147}
2148
2149VersionTuple Triple::getMinimumSupportedOSVersion() const {
2150 if (getVendor() != Triple::Apple || getArch() != Triple::aarch64)
2151 return VersionTuple();
2152 switch (getOS()) {
2153 case Triple::MacOSX:
2154 // ARM64 slice is supported starting from macOS 11.0+.
2155 return VersionTuple(11, 0, 0);
2156 case Triple::IOS:
2157 // ARM64 slice is supported starting from Mac Catalyst 14 (macOS 11).
2158 // ARM64 simulators are supported for iOS 14+.
2159 if (isMacCatalystEnvironment() || isSimulatorEnvironment())
2160 return VersionTuple(14, 0, 0);
2161 // ARM64e slice is supported starting from iOS 14.
2162 if (isArm64e())
2163 return VersionTuple(14, 0, 0);
2164 break;
2165 case Triple::TvOS:
2166 // ARM64 simulators are supported for tvOS 14+.
2167 if (isSimulatorEnvironment())
2168 return VersionTuple(14, 0, 0);
2169 break;
2170 case Triple::WatchOS:
2171 // ARM64 simulators are supported for watchOS 7+.
2172 if (isSimulatorEnvironment())
2173 return VersionTuple(7, 0, 0);
2174 // ARM64/ARM64e slices are supported starting from watchOS 26.
2175 // ARM64_32 is older though.
2176 assert(getArch() != Triple::aarch64_32);
2177 return VersionTuple(26, 0, 0);
2178 case Triple::DriverKit:
2179 return VersionTuple(20, 0, 0);
2180 default:
2181 break;
2182 }
2183 return VersionTuple();
2184}
2185
2186VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind,
2187 const VersionTuple &Version,
2188 bool IsInValidRange) {
2189 const unsigned MacOSRangeBump = 10;
2190 const unsigned IOSRangeBump = 7;
2191 const unsigned XROSRangeBump = 23;
2192 const unsigned WatchOSRangeBump = 14;
2193 switch (OSKind) {
2194 case MacOSX: {
2195 // macOS 10.16 is canonicalized to macOS 11.
2196 if (Version == VersionTuple(10, 16))
2197 return VersionTuple(11, 0);
2198 // macOS 16 is canonicalized to macOS 26.
2199 if (Version == VersionTuple(16, 0))
2200 return VersionTuple(26, 0);
2201 if (!IsInValidRange)
2202 return Version.withMajorReplaced(NewMajor: Version.getMajor() + MacOSRangeBump);
2203 break;
2204 }
2205 case IOS:
2206 case TvOS: {
2207 // Both iOS & tvOS 19.0 canonicalize to 26.
2208 if (Version == VersionTuple(19, 0))
2209 return VersionTuple(26, 0);
2210 if (!IsInValidRange)
2211 return Version.withMajorReplaced(NewMajor: Version.getMajor() + IOSRangeBump);
2212 break;
2213 }
2214 case XROS: {
2215 // visionOS3 is canonicalized to 26.
2216 if (Version == VersionTuple(3, 0))
2217 return VersionTuple(26, 0);
2218 if (!IsInValidRange)
2219 return Version.withMajorReplaced(NewMajor: Version.getMajor() + XROSRangeBump);
2220 break;
2221 }
2222 case WatchOS: {
2223 // watchOS 12 is canonicalized to 26.
2224 if (Version == VersionTuple(12, 0))
2225 return VersionTuple(26, 0);
2226 if (!IsInValidRange)
2227 return Version.withMajorReplaced(NewMajor: Version.getMajor() + WatchOSRangeBump);
2228 break;
2229 }
2230 default:
2231 return Version;
2232 }
2233
2234 return Version;
2235}
2236
2237bool Triple::isValidVersionForOS(OSType OSKind, const VersionTuple &Version) {
2238 /// This constant is used to capture gaps in versioning.
2239 const VersionTuple CommonVersion(26);
2240 auto IsValid = [&](const VersionTuple &StartingVersion) {
2241 return !((Version > StartingVersion) && (Version < CommonVersion));
2242 };
2243 switch (OSKind) {
2244 case WatchOS: {
2245 const VersionTuple StartingWatchOS(12);
2246 return IsValid(StartingWatchOS);
2247 }
2248 case IOS:
2249 case TvOS: {
2250 const VersionTuple StartingIOS(19);
2251 return IsValid(StartingIOS);
2252 }
2253 case MacOSX: {
2254 const VersionTuple StartingMacOS(16);
2255 return IsValid(StartingMacOS);
2256 }
2257 case XROS: {
2258 const VersionTuple StartingXROS(3);
2259 return IsValid(StartingXROS);
2260 }
2261 default:
2262 return true;
2263 }
2264
2265 llvm_unreachable("unexpected or invalid os version");
2266}
2267
2268// HLSL triple environment orders are relied on in the front end
2269static_assert(Triple::Vertex - Triple::Pixel == 1,
2270 "incorrect HLSL stage order");
2271static_assert(Triple::Geometry - Triple::Pixel == 2,
2272 "incorrect HLSL stage order");
2273static_assert(Triple::Hull - Triple::Pixel == 3,
2274 "incorrect HLSL stage order");
2275static_assert(Triple::Domain - Triple::Pixel == 4,
2276 "incorrect HLSL stage order");
2277static_assert(Triple::Compute - Triple::Pixel == 5,
2278 "incorrect HLSL stage order");
2279static_assert(Triple::Library - Triple::Pixel == 6,
2280 "incorrect HLSL stage order");
2281static_assert(Triple::RayGeneration - Triple::Pixel == 7,
2282 "incorrect HLSL stage order");
2283static_assert(Triple::Intersection - Triple::Pixel == 8,
2284 "incorrect HLSL stage order");
2285static_assert(Triple::AnyHit - Triple::Pixel == 9,
2286 "incorrect HLSL stage order");
2287static_assert(Triple::ClosestHit - Triple::Pixel == 10,
2288 "incorrect HLSL stage order");
2289static_assert(Triple::Miss - Triple::Pixel == 11,
2290 "incorrect HLSL stage order");
2291static_assert(Triple::Callable - Triple::Pixel == 12,
2292 "incorrect HLSL stage order");
2293static_assert(Triple::Mesh - Triple::Pixel == 13,
2294 "incorrect HLSL stage order");
2295static_assert(Triple::Amplification - Triple::Pixel == 14,
2296 "incorrect HLSL stage order");
2297

Provided by KDAB

Privacy Policy
Learn to use CMake with our Intro Training
Find out more

source code of llvm/lib/TargetParser/Triple.cpp