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