LLVM 17.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
19#include <cassert>
20#include <cstring>
21using namespace llvm;
22
24 switch (Kind) {
25 case UnknownArch: return "unknown";
26
27 case aarch64: return "aarch64";
28 case aarch64_32: return "aarch64_32";
29 case aarch64_be: return "aarch64_be";
30 case amdgcn: return "amdgcn";
31 case amdil64: return "amdil64";
32 case amdil: return "amdil";
33 case arc: return "arc";
34 case arm: return "arm";
35 case armeb: return "armeb";
36 case avr: return "avr";
37 case bpfeb: return "bpfeb";
38 case bpfel: return "bpfel";
39 case csky: return "csky";
40 case dxil: return "dxil";
41 case hexagon: return "hexagon";
42 case hsail64: return "hsail64";
43 case hsail: return "hsail";
44 case kalimba: return "kalimba";
45 case lanai: return "lanai";
46 case le32: return "le32";
47 case le64: return "le64";
48 case loongarch32: return "loongarch32";
49 case loongarch64: return "loongarch64";
50 case m68k: return "m68k";
51 case mips64: return "mips64";
52 case mips64el: return "mips64el";
53 case mips: return "mips";
54 case mipsel: return "mipsel";
55 case msp430: return "msp430";
56 case nvptx64: return "nvptx64";
57 case nvptx: return "nvptx";
58 case ppc64: return "powerpc64";
59 case ppc64le: return "powerpc64le";
60 case ppc: return "powerpc";
61 case ppcle: return "powerpcle";
62 case r600: return "r600";
63 case renderscript32: return "renderscript32";
64 case renderscript64: return "renderscript64";
65 case riscv32: return "riscv32";
66 case riscv64: return "riscv64";
67 case shave: return "shave";
68 case sparc: return "sparc";
69 case sparcel: return "sparcel";
70 case sparcv9: return "sparcv9";
71 case spir64: return "spir64";
72 case spir: return "spir";
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
93 switch (Kind) {
94 default:
95 return StringRef();
96
97 case aarch64:
98 case aarch64_be:
99 case aarch64_32: return "aarch64";
100
101 case arc: return "arc";
102
103 case arm:
104 case armeb:
105 case thumb:
106 case thumbeb: return "arm";
107
108 case avr: return "avr";
109
110 case ppc64:
111 case ppc64le:
112 case ppc:
113 case ppcle: return "ppc";
114
115 case m68k: return "m68k";
116
117 case mips:
118 case mipsel:
119 case mips64:
120 case mips64el: return "mips";
121
122 case hexagon: return "hexagon";
123
124 case amdgcn: return "amdgcn";
125 case r600: return "r600";
126
127 case bpfel:
128 case bpfeb: return "bpf";
129
130 case sparcv9:
131 case sparcel:
132 case sparc: return "sparc";
133
134 case systemz: return "s390";
135
136 case x86:
137 case x86_64: return "x86";
138
139 case xcore: return "xcore";
140
141 // NVPTX intrinsics are namespaced under nvvm.
142 case nvptx: return "nvvm";
143 case nvptx64: return "nvvm";
144
145 case le32: return "le32";
146 case le64: return "le64";
147
148 case amdil:
149 case amdil64: return "amdil";
150
151 case hsail:
152 case hsail64: return "hsail";
153
154 case spir:
155 case spir64: return "spir";
156
157 case spirv32:
158 case spirv64: return "spirv";
159
160 case kalimba: return "kalimba";
161 case lanai: return "lanai";
162 case shave: return "shave";
163 case wasm32:
164 case wasm64: return "wasm";
165
166 case riscv32:
167 case riscv64: return "riscv";
168
169 case ve: return "ve";
170 case csky: return "csky";
171
172 case loongarch32:
173 case loongarch64: return "loongarch";
174
175 case dxil: return "dx";
176
177 case xtensa: return "xtensa";
178 }
179}
180
182 switch (Kind) {
183 case UnknownVendor: return "unknown";
184
185 case AMD: return "amd";
186 case Apple: return "apple";
187 case CSR: return "csr";
188 case Freescale: return "fsl";
189 case IBM: return "ibm";
190 case ImaginationTechnologies: return "img";
191 case Mesa: return "mesa";
192 case MipsTechnologies: return "mti";
193 case Myriad: return "myriad";
194 case NVIDIA: return "nvidia";
195 case OpenEmbedded: return "oe";
196 case PC: return "pc";
197 case SCEI: return "scei";
198 case SUSE: return "suse";
199 }
200
201 llvm_unreachable("Invalid VendorType!");
202}
203
205 switch (Kind) {
206 case UnknownOS: return "unknown";
207
208 case AIX: return "aix";
209 case AMDHSA: return "amdhsa";
210 case AMDPAL: return "amdpal";
211 case Ananas: return "ananas";
212 case CUDA: return "cuda";
213 case CloudABI: return "cloudabi";
214 case Contiki: return "contiki";
215 case Darwin: return "darwin";
216 case DragonFly: return "dragonfly";
217 case DriverKit: return "driverkit";
218 case ELFIAMCU: return "elfiamcu";
219 case Emscripten: return "emscripten";
220 case FreeBSD: return "freebsd";
221 case Fuchsia: return "fuchsia";
222 case Haiku: return "haiku";
223 case HermitCore: return "hermit";
224 case Hurd: return "hurd";
225 case IOS: return "ios";
226 case KFreeBSD: return "kfreebsd";
227 case Linux: return "linux";
228 case Lv2: return "lv2";
229 case MacOSX: return "macosx";
230 case Mesa3D: return "mesa3d";
231 case Minix: return "minix";
232 case NVCL: return "nvcl";
233 case NaCl: return "nacl";
234 case NetBSD: return "netbsd";
235 case OpenBSD: return "openbsd";
236 case PS4: return "ps4";
237 case PS5: return "ps5";
238 case RTEMS: return "rtems";
239 case Solaris: return "solaris";
240 case TvOS: return "tvos";
241 case WASI: return "wasi";
242 case WatchOS: return "watchos";
243 case Win32: return "windows";
244 case ZOS: return "zos";
245 case ShaderModel: return "shadermodel";
246 }
247
248 llvm_unreachable("Invalid OSType");
249}
250
252 switch (Kind) {
253 case UnknownEnvironment: return "unknown";
254 case Android: return "android";
255 case CODE16: return "code16";
256 case CoreCLR: return "coreclr";
257 case Cygnus: return "cygnus";
258 case EABI: return "eabi";
259 case EABIHF: return "eabihf";
260 case GNU: return "gnu";
261 case GNUABI64: return "gnuabi64";
262 case GNUABIN32: return "gnuabin32";
263 case GNUEABI: return "gnueabi";
264 case GNUEABIHF: return "gnueabihf";
265 case GNUF32: return "gnuf32";
266 case GNUF64: return "gnuf64";
267 case GNUSF: return "gnusf";
268 case GNUX32: return "gnux32";
269 case GNUILP32: return "gnu_ilp32";
270 case Itanium: return "itanium";
271 case MSVC: return "msvc";
272 case MacABI: return "macabi";
273 case Musl: return "musl";
274 case MuslEABI: return "musleabi";
275 case MuslEABIHF: return "musleabihf";
276 case MuslX32: return "muslx32";
277 case Simulator: return "simulator";
278 case Pixel: return "pixel";
279 case Vertex: return "vertex";
280 case Geometry: return "geometry";
281 case Hull: return "hull";
282 case Domain: return "domain";
283 case Compute: return "compute";
284 case Library: return "library";
285 case RayGeneration: return "raygeneration";
286 case Intersection: return "intersection";
287 case AnyHit: return "anyhit";
288 case ClosestHit: return "closesthit";
289 case Miss: return "miss";
290 case Callable: return "callable";
291 case Mesh: return "mesh";
292 case Amplification: return "amplification";
293 }
294
295 llvm_unreachable("Invalid EnvironmentType!");
296}
297
299 if (ArchName.equals("bpf")) {
301 return Triple::bpfel;
302 else
303 return Triple::bpfeb;
304 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
305 return Triple::bpfeb;
306 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
307 return Triple::bpfel;
308 } else {
309 return Triple::UnknownArch;
310 }
311}
312
316 .Case("aarch64", aarch64)
317 .Case("aarch64_be", aarch64_be)
318 .Case("aarch64_32", aarch64_32)
319 .Case("arc", arc)
320 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
321 .Case("arm64_32", aarch64_32)
322 .Case("arm", arm)
323 .Case("armeb", armeb)
324 .Case("avr", avr)
325 .StartsWith("bpf", BPFArch)
326 .Case("m68k", m68k)
327 .Case("mips", mips)
328 .Case("mipsel", mipsel)
329 .Case("mips64", mips64)
330 .Case("mips64el", mips64el)
331 .Case("msp430", msp430)
332 .Case("ppc64", ppc64)
333 .Case("ppc32", ppc)
334 .Case("ppc", ppc)
335 .Case("ppc32le", ppcle)
336 .Case("ppcle", ppcle)
337 .Case("ppc64le", ppc64le)
338 .Case("r600", r600)
339 .Case("amdgcn", amdgcn)
340 .Case("riscv32", riscv32)
341 .Case("riscv64", riscv64)
342 .Case("hexagon", hexagon)
343 .Case("sparc", sparc)
344 .Case("sparcel", sparcel)
345 .Case("sparcv9", sparcv9)
346 .Case("s390x", systemz)
347 .Case("systemz", systemz)
348 .Case("tce", tce)
349 .Case("tcele", tcele)
350 .Case("thumb", thumb)
351 .Case("thumbeb", thumbeb)
352 .Case("x86", x86)
353 .Case("i386", x86)
354 .Case("x86-64", x86_64)
355 .Case("xcore", xcore)
356 .Case("nvptx", nvptx)
357 .Case("nvptx64", nvptx64)
358 .Case("le32", le32)
359 .Case("le64", le64)
360 .Case("amdil", amdil)
361 .Case("amdil64", amdil64)
362 .Case("hsail", hsail)
363 .Case("hsail64", hsail64)
364 .Case("spir", spir)
365 .Case("spir64", spir64)
366 .Case("spirv32", spirv32)
367 .Case("spirv64", spirv64)
368 .Case("kalimba", kalimba)
369 .Case("lanai", lanai)
370 .Case("shave", shave)
371 .Case("wasm32", wasm32)
372 .Case("wasm64", wasm64)
373 .Case("renderscript32", renderscript32)
374 .Case("renderscript64", renderscript64)
375 .Case("ve", ve)
376 .Case("csky", csky)
377 .Case("loongarch32", loongarch32)
378 .Case("loongarch64", loongarch64)
379 .Case("dxil", dxil)
380 .Case("xtensa", xtensa)
382}
383
385 ARM::ISAKind ISA = ARM::parseArchISA(ArchName);
386 ARM::EndianKind ENDIAN = ARM::parseArchEndian(ArchName);
387
389 switch (ENDIAN) {
391 switch (ISA) {
393 arch = Triple::arm;
394 break;
396 arch = Triple::thumb;
397 break;
399 arch = Triple::aarch64;
400 break;
402 break;
403 }
404 break;
405 }
407 switch (ISA) {
409 arch = Triple::armeb;
410 break;
412 arch = Triple::thumbeb;
413 break;
415 arch = Triple::aarch64_be;
416 break;
418 break;
419 }
420 break;
421 }
423 break;
424 }
425 }
426
427 ArchName = ARM::getCanonicalArchName(ArchName);
428 if (ArchName.empty())
429 return Triple::UnknownArch;
430
431 // Thumb only exists in v4+
432 if (ISA == ARM::ISAKind::THUMB &&
433 (ArchName.startswith("v2") || ArchName.startswith("v3")))
434 return Triple::UnknownArch;
435
436 // Thumb only for v6m
438 unsigned Version = ARM::parseArchVersion(ArchName);
439 if (Profile == ARM::ProfileKind::M && Version == 6) {
440 if (ENDIAN == ARM::EndianKind::BIG)
441 return Triple::thumbeb;
442 else
443 return Triple::thumb;
444 }
445
446 return arch;
447}
448
450 auto AT = StringSwitch<Triple::ArchType>(ArchName)
451 .Cases("i386", "i486", "i586", "i686", Triple::x86)
452 // FIXME: Do we need to support these?
453 .Cases("i786", "i886", "i986", Triple::x86)
454 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
455 .Cases("powerpc", "powerpcspe", "ppc", "ppc32", Triple::ppc)
456 .Cases("powerpcle", "ppcle", "ppc32le", Triple::ppcle)
457 .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)
458 .Cases("powerpc64le", "ppc64le", Triple::ppc64le)
459 .Case("xscale", Triple::arm)
460 .Case("xscaleeb", Triple::armeb)
461 .Case("aarch64", Triple::aarch64)
462 .Case("aarch64_be", Triple::aarch64_be)
463 .Case("aarch64_32", Triple::aarch64_32)
464 .Case("arc", Triple::arc)
465 .Case("arm64", Triple::aarch64)
466 .Case("arm64_32", Triple::aarch64_32)
467 .Case("arm64e", Triple::aarch64)
468 .Case("arm64ec", Triple::aarch64)
469 .Case("arm", Triple::arm)
470 .Case("armeb", Triple::armeb)
471 .Case("thumb", Triple::thumb)
472 .Case("thumbeb", Triple::thumbeb)
473 .Case("avr", Triple::avr)
474 .Case("m68k", Triple::m68k)
475 .Case("msp430", Triple::msp430)
476 .Cases("mips", "mipseb", "mipsallegrex", "mipsisa32r6",
477 "mipsr6", Triple::mips)
478 .Cases("mipsel", "mipsallegrexel", "mipsisa32r6el", "mipsr6el",
480 .Cases("mips64", "mips64eb", "mipsn32", "mipsisa64r6",
481 "mips64r6", "mipsn32r6", Triple::mips64)
482 .Cases("mips64el", "mipsn32el", "mipsisa64r6el", "mips64r6el",
483 "mipsn32r6el", Triple::mips64el)
484 .Case("r600", Triple::r600)
485 .Case("amdgcn", Triple::amdgcn)
486 .Case("riscv32", Triple::riscv32)
487 .Case("riscv64", Triple::riscv64)
488 .Case("hexagon", Triple::hexagon)
489 .Cases("s390x", "systemz", Triple::systemz)
490 .Case("sparc", Triple::sparc)
491 .Case("sparcel", Triple::sparcel)
492 .Cases("sparcv9", "sparc64", Triple::sparcv9)
493 .Case("tce", Triple::tce)
494 .Case("tcele", Triple::tcele)
495 .Case("xcore", Triple::xcore)
496 .Case("nvptx", Triple::nvptx)
497 .Case("nvptx64", Triple::nvptx64)
498 .Case("le32", Triple::le32)
499 .Case("le64", Triple::le64)
500 .Case("amdil", Triple::amdil)
501 .Case("amdil64", Triple::amdil64)
502 .Case("hsail", Triple::hsail)
503 .Case("hsail64", Triple::hsail64)
504 .Case("spir", Triple::spir)
505 .Case("spir64", Triple::spir64)
506 .Cases("spirv32", "spirv32v1.0", "spirv32v1.1", "spirv32v1.2",
507 "spirv32v1.3", "spirv32v1.4", "spirv32v1.5", Triple::spirv32)
508 .Cases("spirv64", "spirv64v1.0", "spirv64v1.1", "spirv64v1.2",
509 "spirv64v1.3", "spirv64v1.4", "spirv64v1.5", Triple::spirv64)
510 .StartsWith("kalimba", Triple::kalimba)
511 .Case("lanai", Triple::lanai)
512 .Case("renderscript32", Triple::renderscript32)
513 .Case("renderscript64", Triple::renderscript64)
514 .Case("shave", Triple::shave)
515 .Case("ve", Triple::ve)
516 .Case("wasm32", Triple::wasm32)
517 .Case("wasm64", Triple::wasm64)
518 .Case("csky", Triple::csky)
519 .Case("loongarch32", Triple::loongarch32)
520 .Case("loongarch64", Triple::loongarch64)
521 .Case("dxil", Triple::dxil)
522 .Case("xtensa", Triple::xtensa)
524
525 // Some architectures require special parsing logic just to compute the
526 // ArchType result.
527 if (AT == Triple::UnknownArch) {
528 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
529 ArchName.startswith("aarch64"))
530 return parseARMArch(ArchName);
531 if (ArchName.startswith("bpf"))
532 return parseBPFArch(ArchName);
533 }
534
535 return AT;
536}
537
539 return StringSwitch<Triple::VendorType>(VendorName)
540 .Case("apple", Triple::Apple)
541 .Case("pc", Triple::PC)
542 .Case("scei", Triple::SCEI)
543 .Case("sie", Triple::SCEI)
544 .Case("fsl", Triple::Freescale)
545 .Case("ibm", Triple::IBM)
548 .Case("nvidia", Triple::NVIDIA)
549 .Case("csr", Triple::CSR)
550 .Case("myriad", Triple::Myriad)
551 .Case("amd", Triple::AMD)
552 .Case("mesa", Triple::Mesa)
553 .Case("suse", Triple::SUSE)
556}
557
559 return StringSwitch<Triple::OSType>(OSName)
560 .StartsWith("ananas", Triple::Ananas)
561 .StartsWith("cloudabi", Triple::CloudABI)
562 .StartsWith("darwin", Triple::Darwin)
563 .StartsWith("dragonfly", Triple::DragonFly)
564 .StartsWith("freebsd", Triple::FreeBSD)
565 .StartsWith("fuchsia", Triple::Fuchsia)
566 .StartsWith("ios", Triple::IOS)
567 .StartsWith("kfreebsd", Triple::KFreeBSD)
568 .StartsWith("linux", Triple::Linux)
569 .StartsWith("lv2", Triple::Lv2)
570 .StartsWith("macos", Triple::MacOSX)
571 .StartsWith("netbsd", Triple::NetBSD)
572 .StartsWith("openbsd", Triple::OpenBSD)
573 .StartsWith("solaris", Triple::Solaris)
574 .StartsWith("win32", Triple::Win32)
575 .StartsWith("windows", Triple::Win32)
576 .StartsWith("zos", Triple::ZOS)
577 .StartsWith("haiku", Triple::Haiku)
578 .StartsWith("minix", Triple::Minix)
579 .StartsWith("rtems", Triple::RTEMS)
580 .StartsWith("nacl", Triple::NaCl)
581 .StartsWith("aix", Triple::AIX)
582 .StartsWith("cuda", Triple::CUDA)
583 .StartsWith("nvcl", Triple::NVCL)
584 .StartsWith("amdhsa", Triple::AMDHSA)
585 .StartsWith("ps4", Triple::PS4)
586 .StartsWith("ps5", Triple::PS5)
587 .StartsWith("elfiamcu", Triple::ELFIAMCU)
588 .StartsWith("tvos", Triple::TvOS)
589 .StartsWith("watchos", Triple::WatchOS)
590 .StartsWith("driverkit", Triple::DriverKit)
591 .StartsWith("mesa3d", Triple::Mesa3D)
592 .StartsWith("contiki", Triple::Contiki)
593 .StartsWith("amdpal", Triple::AMDPAL)
595 .StartsWith("hurd", Triple::Hurd)
596 .StartsWith("wasi", Triple::WASI)
597 .StartsWith("emscripten", Triple::Emscripten)
598 .StartsWith("shadermodel", Triple::ShaderModel)
600}
601
603 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
604 .StartsWith("eabihf", Triple::EABIHF)
605 .StartsWith("eabi", Triple::EABI)
606 .StartsWith("gnuabin32", Triple::GNUABIN32)
607 .StartsWith("gnuabi64", Triple::GNUABI64)
608 .StartsWith("gnueabihf", Triple::GNUEABIHF)
609 .StartsWith("gnueabi", Triple::GNUEABI)
610 .StartsWith("gnuf32", Triple::GNUF32)
611 .StartsWith("gnuf64", Triple::GNUF64)
612 .StartsWith("gnusf", Triple::GNUSF)
613 .StartsWith("gnux32", Triple::GNUX32)
614 .StartsWith("gnu_ilp32", Triple::GNUILP32)
615 .StartsWith("code16", Triple::CODE16)
616 .StartsWith("gnu", Triple::GNU)
617 .StartsWith("android", Triple::Android)
618 .StartsWith("musleabihf", Triple::MuslEABIHF)
619 .StartsWith("musleabi", Triple::MuslEABI)
620 .StartsWith("muslx32", Triple::MuslX32)
621 .StartsWith("musl", Triple::Musl)
622 .StartsWith("msvc", Triple::MSVC)
623 .StartsWith("itanium", Triple::Itanium)
624 .StartsWith("cygnus", Triple::Cygnus)
625 .StartsWith("coreclr", Triple::CoreCLR)
626 .StartsWith("simulator", Triple::Simulator)
627 .StartsWith("macabi", Triple::MacABI)
628 .StartsWith("pixel", Triple::Pixel)
629 .StartsWith("vertex", Triple::Vertex)
630 .StartsWith("geometry", Triple::Geometry)
631 .StartsWith("hull", Triple::Hull)
632 .StartsWith("domain", Triple::Domain)
633 .StartsWith("compute", Triple::Compute)
634 .StartsWith("library", Triple::Library)
635 .StartsWith("raygeneration", Triple::RayGeneration)
636 .StartsWith("intersection", Triple::Intersection)
637 .StartsWith("anyhit", Triple::AnyHit)
638 .StartsWith("closesthit", Triple::ClosestHit)
639 .StartsWith("miss", Triple::Miss)
640 .StartsWith("callable", Triple::Callable)
641 .StartsWith("mesh", Triple::Mesh)
642 .StartsWith("amplification", Triple::Amplification)
644}
645
647 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
648 // "xcoff" must come before "coff" because of the order-dependendent
649 // pattern matching.
650 .EndsWith("xcoff", Triple::XCOFF)
651 .EndsWith("coff", Triple::COFF)
652 .EndsWith("elf", Triple::ELF)
653 .EndsWith("goff", Triple::GOFF)
654 .EndsWith("macho", Triple::MachO)
655 .EndsWith("wasm", Triple::Wasm)
656 .EndsWith("spirv", Triple::SPIRV)
658}
659
661 if (SubArchName.startswith("mips") &&
662 (SubArchName.endswith("r6el") || SubArchName.endswith("r6")))
664
665 if (SubArchName == "powerpcspe")
667
668 if (SubArchName == "arm64e")
670
671 if (SubArchName == "arm64ec")
673
674 if (SubArchName.startswith("spirv"))
675 return StringSwitch<Triple::SubArchType>(SubArchName)
683
684 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
685
686 // For now, this is the small part. Early return.
687 if (ARMSubArch.empty())
688 return StringSwitch<Triple::SubArchType>(SubArchName)
693
694 // ARM sub arch.
695 switch(ARM::parseArch(ARMSubArch)) {
696 case ARM::ArchKind::ARMV4:
697 return Triple::NoSubArch;
698 case ARM::ArchKind::ARMV4T:
700 case ARM::ArchKind::ARMV5T:
702 case ARM::ArchKind::ARMV5TE:
703 case ARM::ArchKind::IWMMXT:
704 case ARM::ArchKind::IWMMXT2:
705 case ARM::ArchKind::XSCALE:
706 case ARM::ArchKind::ARMV5TEJ:
708 case ARM::ArchKind::ARMV6:
710 case ARM::ArchKind::ARMV6K:
711 case ARM::ArchKind::ARMV6KZ:
713 case ARM::ArchKind::ARMV6T2:
715 case ARM::ArchKind::ARMV6M:
717 case ARM::ArchKind::ARMV7A:
718 case ARM::ArchKind::ARMV7R:
720 case ARM::ArchKind::ARMV7VE:
722 case ARM::ArchKind::ARMV7K:
724 case ARM::ArchKind::ARMV7M:
726 case ARM::ArchKind::ARMV7S:
728 case ARM::ArchKind::ARMV7EM:
730 case ARM::ArchKind::ARMV8A:
732 case ARM::ArchKind::ARMV8_1A:
734 case ARM::ArchKind::ARMV8_2A:
736 case ARM::ArchKind::ARMV8_3A:
738 case ARM::ArchKind::ARMV8_4A:
740 case ARM::ArchKind::ARMV8_5A:
742 case ARM::ArchKind::ARMV8_6A:
744 case ARM::ArchKind::ARMV8_7A:
746 case ARM::ArchKind::ARMV8_8A:
748 case ARM::ArchKind::ARMV8_9A:
750 case ARM::ArchKind::ARMV9A:
752 case ARM::ArchKind::ARMV9_1A:
754 case ARM::ArchKind::ARMV9_2A:
756 case ARM::ArchKind::ARMV9_3A:
758 case ARM::ArchKind::ARMV9_4A:
760 case ARM::ArchKind::ARMV8R:
762 case ARM::ArchKind::ARMV8MBaseline:
764 case ARM::ArchKind::ARMV8MMainline:
766 case ARM::ArchKind::ARMV8_1MMainline:
768 default:
769 return Triple::NoSubArch;
770 }
771}
772
774 switch (Kind) {
776 return "";
777 case Triple::COFF:
778 return "coff";
779 case Triple::ELF:
780 return "elf";
781 case Triple::GOFF:
782 return "goff";
783 case Triple::MachO:
784 return "macho";
785 case Triple::Wasm:
786 return "wasm";
787 case Triple::XCOFF:
788 return "xcoff";
790 return "dxcontainer";
791 case Triple::SPIRV:
792 return "spirv";
793 }
794 llvm_unreachable("unknown object format type");
795}
796
798 switch (T.getArch()) {
800 case Triple::aarch64:
802 case Triple::arm:
803 case Triple::thumb:
804 case Triple::x86:
805 case Triple::x86_64:
806 if (T.isOSDarwin())
807 return Triple::MachO;
808 else if (T.isOSWindows())
809 return Triple::COFF;
810 return Triple::ELF;
811
813 case Triple::amdgcn:
814 case Triple::amdil64:
815 case Triple::amdil:
816 case Triple::arc:
817 case Triple::armeb:
818 case Triple::avr:
819 case Triple::bpfeb:
820 case Triple::bpfel:
821 case Triple::csky:
822 case Triple::hexagon:
823 case Triple::hsail64:
824 case Triple::hsail:
825 case Triple::kalimba:
826 case Triple::lanai:
827 case Triple::le32:
828 case Triple::le64:
831 case Triple::m68k:
832 case Triple::mips64:
833 case Triple::mips64el:
834 case Triple::mips:
835 case Triple::mipsel:
836 case Triple::msp430:
837 case Triple::nvptx64:
838 case Triple::nvptx:
839 case Triple::ppc64le:
840 case Triple::ppcle:
841 case Triple::r600:
844 case Triple::riscv32:
845 case Triple::riscv64:
846 case Triple::shave:
847 case Triple::sparc:
848 case Triple::sparcel:
849 case Triple::sparcv9:
850 case Triple::spir64:
851 case Triple::spir:
852 case Triple::tce:
853 case Triple::tcele:
854 case Triple::thumbeb:
855 case Triple::ve:
856 case Triple::xcore:
857 case Triple::xtensa:
858 return Triple::ELF;
859
860 case Triple::ppc64:
861 case Triple::ppc:
862 if (T.isOSAIX())
863 return Triple::XCOFF;
864 return Triple::ELF;
865
866 case Triple::systemz:
867 if (T.isOSzOS())
868 return Triple::GOFF;
869 return Triple::ELF;
870
871 case Triple::wasm32:
872 case Triple::wasm64:
873 return Triple::Wasm;
874
875 case Triple::spirv32:
876 case Triple::spirv64:
877 return Triple::SPIRV;
878
879 case Triple::dxil:
880 return Triple::DXContainer;
881 }
882 llvm_unreachable("unknown architecture");
883}
884
885/// Construct a triple from the string representation provided.
886///
887/// This stores the string representation and parses the various pieces into
888/// enum members.
890 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
891 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
892 ObjectFormat(UnknownObjectFormat) {
893 // Do minimal parsing by hand here.
894 SmallVector<StringRef, 4> Components;
895 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
896 if (Components.size() > 0) {
897 Arch = parseArch(Components[0]);
898 SubArch = parseSubArch(Components[0]);
899 if (Components.size() > 1) {
900 Vendor = parseVendor(Components[1]);
901 if (Components.size() > 2) {
902 OS = parseOS(Components[2]);
903 if (Components.size() > 3) {
904 Environment = parseEnvironment(Components[3]);
905 ObjectFormat = parseFormat(Components[3]);
906 }
907 }
908 } else {
909 Environment =
911 .StartsWith("mipsn32", Triple::GNUABIN32)
912 .StartsWith("mips64", Triple::GNUABI64)
913 .StartsWith("mipsisa64", Triple::GNUABI64)
914 .StartsWith("mipsisa32", Triple::GNU)
915 .Cases("mips", "mipsel", "mipsr6", "mipsr6el", Triple::GNU)
917 }
918 }
919 if (ObjectFormat == UnknownObjectFormat)
920 ObjectFormat = getDefaultFormat(*this);
921}
922
923/// Construct a triple from string representations of the architecture,
924/// vendor, and OS.
925///
926/// This joins each argument into a canonical string representation and parses
927/// them into enum members. It leaves the environment unknown and omits it from
928/// the string representation.
929Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
930 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
931 Arch(parseArch(ArchStr.str())),
932 SubArch(parseSubArch(ArchStr.str())),
933 Vendor(parseVendor(VendorStr.str())),
934 OS(parseOS(OSStr.str())),
935 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
936 ObjectFormat = getDefaultFormat(*this);
937}
938
939/// Construct a triple from string representations of the architecture,
940/// vendor, OS, and environment.
941///
942/// This joins each argument into a canonical string representation and parses
943/// them into enum members.
944Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
945 const Twine &EnvironmentStr)
946 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
947 EnvironmentStr).str()),
948 Arch(parseArch(ArchStr.str())),
949 SubArch(parseSubArch(ArchStr.str())),
950 Vendor(parseVendor(VendorStr.str())),
951 OS(parseOS(OSStr.str())),
952 Environment(parseEnvironment(EnvironmentStr.str())),
953 ObjectFormat(parseFormat(EnvironmentStr.str())) {
954 if (ObjectFormat == Triple::UnknownObjectFormat)
955 ObjectFormat = getDefaultFormat(*this);
956}
957
958std::string Triple::normalize(StringRef Str) {
959 bool IsMinGW32 = false;
960 bool IsCygwin = false;
961
962 // Parse into components.
963 SmallVector<StringRef, 4> Components;
964 Str.split(Components, '-');
965
966 // If the first component corresponds to a known architecture, preferentially
967 // use it for the architecture. If the second component corresponds to a
968 // known vendor, preferentially use it for the vendor, etc. This avoids silly
969 // component movement when a component parses as (eg) both a valid arch and a
970 // valid os.
971 ArchType Arch = UnknownArch;
972 if (Components.size() > 0)
973 Arch = parseArch(Components[0]);
974 VendorType Vendor = UnknownVendor;
975 if (Components.size() > 1)
976 Vendor = parseVendor(Components[1]);
977 OSType OS = UnknownOS;
978 if (Components.size() > 2) {
979 OS = parseOS(Components[2]);
980 IsCygwin = Components[2].startswith("cygwin");
981 IsMinGW32 = Components[2].startswith("mingw");
982 }
984 if (Components.size() > 3)
985 Environment = parseEnvironment(Components[3]);
987 if (Components.size() > 4)
988 ObjectFormat = parseFormat(Components[4]);
989
990 // Note which components are already in their final position. These will not
991 // be moved.
992 bool Found[4];
993 Found[0] = Arch != UnknownArch;
994 Found[1] = Vendor != UnknownVendor;
995 Found[2] = OS != UnknownOS;
996 Found[3] = Environment != UnknownEnvironment;
997
998 // If they are not there already, permute the components into their canonical
999 // positions by seeing if they parse as a valid architecture, and if so moving
1000 // the component to the architecture position etc.
1001 for (unsigned Pos = 0; Pos != std::size(Found); ++Pos) {
1002 if (Found[Pos])
1003 continue; // Already in the canonical position.
1004
1005 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
1006 // Do not reparse any components that already matched.
1007 if (Idx < std::size(Found) && Found[Idx])
1008 continue;
1009
1010 // Does this component parse as valid for the target position?
1011 bool Valid = false;
1012 StringRef Comp = Components[Idx];
1013 switch (Pos) {
1014 default: llvm_unreachable("unexpected component type!");
1015 case 0:
1016 Arch = parseArch(Comp);
1017 Valid = Arch != UnknownArch;
1018 break;
1019 case 1:
1020 Vendor = parseVendor(Comp);
1021 Valid = Vendor != UnknownVendor;
1022 break;
1023 case 2:
1024 OS = parseOS(Comp);
1025 IsCygwin = Comp.startswith("cygwin");
1026 IsMinGW32 = Comp.startswith("mingw");
1027 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
1028 break;
1029 case 3:
1030 Environment = parseEnvironment(Comp);
1031 Valid = Environment != UnknownEnvironment;
1032 if (!Valid) {
1033 ObjectFormat = parseFormat(Comp);
1034 Valid = ObjectFormat != UnknownObjectFormat;
1035 }
1036 break;
1037 }
1038 if (!Valid)
1039 continue; // Nope, try the next component.
1040
1041 // Move the component to the target position, pushing any non-fixed
1042 // components that are in the way to the right. This tends to give
1043 // good results in the common cases of a forgotten vendor component
1044 // or a wrongly positioned environment.
1045 if (Pos < Idx) {
1046 // Insert left, pushing the existing components to the right. For
1047 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
1048 StringRef CurrentComponent(""); // The empty component.
1049 // Replace the component we are moving with an empty component.
1050 std::swap(CurrentComponent, Components[Idx]);
1051 // Insert the component being moved at Pos, displacing any existing
1052 // components to the right.
1053 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
1054 // Skip over any fixed components.
1055 while (i < std::size(Found) && Found[i])
1056 ++i;
1057 // Place the component at the new position, getting the component
1058 // that was at this position - it will be moved right.
1059 std::swap(CurrentComponent, Components[i]);
1060 }
1061 } else if (Pos > Idx) {
1062 // Push right by inserting empty components until the component at Idx
1063 // reaches the target position Pos. For example, pc-a -> -pc-a when
1064 // moving pc to the second position.
1065 do {
1066 // Insert one empty component at Idx.
1067 StringRef CurrentComponent(""); // The empty component.
1068 for (unsigned i = Idx; i < Components.size();) {
1069 // Place the component at the new position, getting the component
1070 // that was at this position - it will be moved right.
1071 std::swap(CurrentComponent, Components[i]);
1072 // If it was placed on top of an empty component then we are done.
1073 if (CurrentComponent.empty())
1074 break;
1075 // Advance to the next component, skipping any fixed components.
1076 while (++i < std::size(Found) && Found[i])
1077 ;
1078 }
1079 // The last component was pushed off the end - append it.
1080 if (!CurrentComponent.empty())
1081 Components.push_back(CurrentComponent);
1082
1083 // Advance Idx to the component's new position.
1084 while (++Idx < std::size(Found) && Found[Idx])
1085 ;
1086 } while (Idx < Pos); // Add more until the final position is reached.
1087 }
1088 assert(Pos < Components.size() && Components[Pos] == Comp &&
1089 "Component moved wrong!");
1090 Found[Pos] = true;
1091 break;
1092 }
1093 }
1094
1095 // Replace empty components with "unknown" value.
1096 for (StringRef &C : Components)
1097 if (C.empty())
1098 C = "unknown";
1099
1100 // Special case logic goes here. At this point Arch, Vendor and OS have the
1101 // correct values for the computed components.
1102 std::string NormalizedEnvironment;
1103 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
1104 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
1105 if (AndroidVersion.empty()) {
1106 Components[3] = "android";
1107 } else {
1108 NormalizedEnvironment = Twine("android", AndroidVersion).str();
1109 Components[3] = NormalizedEnvironment;
1110 }
1111 }
1112
1113 // SUSE uses "gnueabi" to mean "gnueabihf"
1114 if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI)
1115 Components[3] = "gnueabihf";
1116
1117 if (OS == Triple::Win32) {
1118 Components.resize(4);
1119 Components[2] = "windows";
1120 if (Environment == UnknownEnvironment) {
1121 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
1122 Components[3] = "msvc";
1123 else
1124 Components[3] = getObjectFormatTypeName(ObjectFormat);
1125 }
1126 } else if (IsMinGW32) {
1127 Components.resize(4);
1128 Components[2] = "windows";
1129 Components[3] = "gnu";
1130 } else if (IsCygwin) {
1131 Components.resize(4);
1132 Components[2] = "windows";
1133 Components[3] = "cygnus";
1134 }
1135 if (IsMinGW32 || IsCygwin ||
1136 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
1137 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
1138 Components.resize(5);
1139 Components[4] = getObjectFormatTypeName(ObjectFormat);
1140 }
1141 }
1142
1143 // Stick the corrected components back together to form the normalized string.
1144 return join(Components, "-");
1145}
1146
1148 return StringRef(Data).split('-').first; // Isolate first component
1149}
1150
1152 switch (Kind) {
1153 case Triple::mips:
1154 if (SubArch == MipsSubArch_r6)
1155 return "mipsisa32r6";
1156 break;
1157 case Triple::mipsel:
1158 if (SubArch == MipsSubArch_r6)
1159 return "mipsisa32r6el";
1160 break;
1161 case Triple::mips64:
1162 if (SubArch == MipsSubArch_r6)
1163 return "mipsisa64r6";
1164 break;
1165 case Triple::mips64el:
1166 if (SubArch == MipsSubArch_r6)
1167 return "mipsisa64r6el";
1168 break;
1169 case Triple::aarch64:
1170 if (SubArch == AArch64SubArch_arm64ec)
1171 return "arm64ec";
1172 break;
1173 default:
1174 break;
1175 }
1176 return getArchTypeName(Kind);
1177}
1178
1180 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
1181 return Tmp.split('-').first; // Isolate second component
1182}
1183
1185 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
1186 Tmp = Tmp.split('-').second; // Strip second component
1187 return Tmp.split('-').first; // Isolate third component
1188}
1189
1191 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
1192 Tmp = Tmp.split('-').second; // Strip second component
1193 return Tmp.split('-').second; // Strip third component
1194}
1195
1197 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
1198 return Tmp.split('-').second; // Strip second component
1199}
1200
1202 VersionTuple Version;
1203 Version.tryParse(Name);
1204 return Version.withoutBuild();
1205}
1206
1208 StringRef EnvironmentName = getEnvironmentName();
1209 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
1210 if (EnvironmentName.startswith(EnvironmentTypeName))
1211 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
1212
1213 return parseVersionFromName(EnvironmentName);
1214}
1215
1217 StringRef OSName = getOSName();
1218 // Assume that the OS portion of the triple starts with the canonical name.
1219 StringRef OSTypeName = getOSTypeName(getOS());
1220 if (OSName.startswith(OSTypeName))
1221 OSName = OSName.substr(OSTypeName.size());
1222 else if (getOS() == MacOSX)
1223 OSName.consume_front("macos");
1224
1225 return parseVersionFromName(OSName);
1226}
1227
1229 Version = getOSVersion();
1230
1231 switch (getOS()) {
1232 default: llvm_unreachable("unexpected OS for Darwin triple");
1233 case Darwin:
1234 // Default to darwin8, i.e., MacOSX 10.4.
1235 if (Version.getMajor() == 0)
1236 Version = VersionTuple(8);
1237 // Darwin version numbers are skewed from OS X versions.
1238 if (Version.getMajor() < 4) {
1239 return false;
1240 }
1241 if (Version.getMajor() <= 19) {
1242 Version = VersionTuple(10, Version.getMajor() - 4);
1243 } else {
1244 // darwin20+ corresponds to macOS 11+.
1245 Version = VersionTuple(11 + Version.getMajor() - 20);
1246 }
1247 break;
1248 case MacOSX:
1249 // Default to 10.4.
1250 if (Version.getMajor() == 0) {
1251 Version = VersionTuple(10, 4);
1252 } else if (Version.getMajor() < 10) {
1253 return false;
1254 }
1255 break;
1256 case IOS:
1257 case TvOS:
1258 case WatchOS:
1259 // Ignore the version from the triple. This is only handled because the
1260 // the clang driver combines OS X and IOS support into a common Darwin
1261 // toolchain that wants to know the OS X version number even when targeting
1262 // IOS.
1263 Version = VersionTuple(10, 4);
1264 break;
1265 case DriverKit:
1266 llvm_unreachable("OSX version isn't relevant for DriverKit");
1267 }
1268 return true;
1269}
1270
1272 switch (getOS()) {
1273 default: llvm_unreachable("unexpected OS for Darwin triple");
1274 case Darwin:
1275 case MacOSX:
1276 // Ignore the version from the triple. This is only handled because the
1277 // the clang driver combines OS X and IOS support into a common Darwin
1278 // toolchain that wants to know the iOS version number even when targeting
1279 // OS X.
1280 return VersionTuple(5);
1281 case IOS:
1282 case TvOS: {
1283 VersionTuple Version = getOSVersion();
1284 // Default to 5.0 (or 7.0 for arm64).
1285 if (Version.getMajor() == 0)
1286 return (getArch() == aarch64) ? VersionTuple(7) : VersionTuple(5);
1287 return Version;
1288 }
1289 case WatchOS:
1290 llvm_unreachable("conflicting triple info");
1291 case DriverKit:
1292 llvm_unreachable("DriverKit doesn't have an iOS version");
1293 }
1294}
1295
1297 switch (getOS()) {
1298 default: llvm_unreachable("unexpected OS for Darwin triple");
1299 case Darwin:
1300 case MacOSX:
1301 // Ignore the version from the triple. This is only handled because the
1302 // the clang driver combines OS X and IOS support into a common Darwin
1303 // toolchain that wants to know the iOS version number even when targeting
1304 // OS X.
1305 return VersionTuple(2);
1306 case WatchOS: {
1307 VersionTuple Version = getOSVersion();
1308 if (Version.getMajor() == 0)
1309 return VersionTuple(2);
1310 return Version;
1311 }
1312 case IOS:
1313 llvm_unreachable("conflicting triple info");
1314 case DriverKit:
1315 llvm_unreachable("DriverKit doesn't have a WatchOS version");
1316 }
1317}
1318
1320 switch (getOS()) {
1321 default:
1322 llvm_unreachable("unexpected OS for Darwin triple");
1323 case DriverKit:
1324 VersionTuple Version = getOSVersion();
1325 if (Version.getMajor() == 0)
1326 return Version.withMajorReplaced(19);
1327 return Version;
1328 }
1329}
1330
1331void Triple::setTriple(const Twine &Str) {
1332 *this = Triple(Str);
1333}
1334
1336 setArchName(getArchName(Kind, SubArch));
1337}
1338
1341}
1342
1344 setOSName(getOSTypeName(Kind));
1345}
1346
1348 if (ObjectFormat == getDefaultFormat(*this))
1350
1352 getObjectFormatTypeName(ObjectFormat)).str());
1353}
1354
1356 if (Environment == UnknownEnvironment)
1358
1359 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1360 getObjectFormatTypeName(Kind)).str());
1361}
1362
1364 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1366 Triple += Str;
1367 Triple += "-";
1368 Triple += getVendorName();
1369 Triple += "-";
1372}
1373
1375 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1376}
1377
1379 if (hasEnvironment())
1380 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1381 "-" + getEnvironmentName());
1382 else
1383 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1384}
1385
1387 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1388 "-" + Str);
1389}
1390
1392 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1393}
1394
1396 switch (Arch) {
1398 return 0;
1399
1400 case llvm::Triple::avr:
1402 return 16;
1403
1406 case llvm::Triple::arc:
1407 case llvm::Triple::arm:
1409 case llvm::Triple::csky:
1410 case llvm::Triple::dxil:
1415 case llvm::Triple::le32:
1417 case llvm::Triple::m68k:
1418 case llvm::Triple::mips:
1421 case llvm::Triple::ppc:
1423 case llvm::Triple::r600:
1429 case llvm::Triple::spir:
1431 case llvm::Triple::tce:
1436 case llvm::Triple::x86:
1439 return 32;
1440
1448 case llvm::Triple::le64:
1461 case llvm::Triple::ve:
1464 return 64;
1465 }
1466 llvm_unreachable("Invalid architecture value");
1467}
1468
1470 return getArchPointerBitWidth(getArch()) == 64;
1471}
1472
1474 return getArchPointerBitWidth(getArch()) == 32;
1475}
1476
1478 return getArchPointerBitWidth(getArch()) == 16;
1479}
1480
1482 Triple T(*this);
1483 switch (getArch()) {
1485 case Triple::amdgcn:
1486 case Triple::avr:
1487 case Triple::bpfeb:
1488 case Triple::bpfel:
1489 case Triple::msp430:
1490 case Triple::systemz:
1491 case Triple::ve:
1492 T.setArch(UnknownArch);
1493 break;
1494
1495 case Triple::aarch64_32:
1496 case Triple::amdil:
1497 case Triple::arc:
1498 case Triple::arm:
1499 case Triple::armeb:
1500 case Triple::csky:
1501 case Triple::dxil:
1502 case Triple::hexagon:
1503 case Triple::hsail:
1504 case Triple::kalimba:
1505 case Triple::lanai:
1506 case Triple::le32:
1508 case Triple::m68k:
1509 case Triple::mips:
1510 case Triple::mipsel:
1511 case Triple::nvptx:
1512 case Triple::ppc:
1513 case Triple::ppcle:
1514 case Triple::r600:
1516 case Triple::riscv32:
1517 case Triple::shave:
1518 case Triple::sparc:
1519 case Triple::sparcel:
1520 case Triple::spir:
1521 case Triple::spirv32:
1522 case Triple::tce:
1523 case Triple::tcele:
1524 case Triple::thumb:
1525 case Triple::thumbeb:
1526 case Triple::wasm32:
1527 case Triple::x86:
1528 case Triple::xcore:
1529 case Triple::xtensa:
1530 // Already 32-bit.
1531 break;
1532
1533 case Triple::aarch64: T.setArch(Triple::arm); break;
1534 case Triple::aarch64_be: T.setArch(Triple::armeb); break;
1535 case Triple::amdil64: T.setArch(Triple::amdil); break;
1536 case Triple::hsail64: T.setArch(Triple::hsail); break;
1537 case Triple::le64: T.setArch(Triple::le32); break;
1538 case Triple::loongarch64: T.setArch(Triple::loongarch32); break;
1539 case Triple::mips64:
1540 T.setArch(Triple::mips, getSubArch());
1541 break;
1542 case Triple::mips64el:
1543 T.setArch(Triple::mipsel, getSubArch());
1544 break;
1545 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1546 case Triple::ppc64: T.setArch(Triple::ppc); break;
1547 case Triple::ppc64le: T.setArch(Triple::ppcle); break;
1548 case Triple::renderscript64: T.setArch(Triple::renderscript32); break;
1549 case Triple::riscv64: T.setArch(Triple::riscv32); break;
1550 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1551 case Triple::spir64: T.setArch(Triple::spir); break;
1552 case Triple::spirv64:
1553 T.setArch(Triple::spirv32, getSubArch());
1554 break;
1555 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1556 case Triple::x86_64: T.setArch(Triple::x86); break;
1557 }
1558 return T;
1559}
1560
1562 Triple T(*this);
1563 switch (getArch()) {
1565 case Triple::arc:
1566 case Triple::avr:
1567 case Triple::csky:
1568 case Triple::dxil:
1569 case Triple::hexagon:
1570 case Triple::kalimba:
1571 case Triple::lanai:
1572 case Triple::m68k:
1573 case Triple::msp430:
1574 case Triple::r600:
1575 case Triple::shave:
1576 case Triple::sparcel:
1577 case Triple::tce:
1578 case Triple::tcele:
1579 case Triple::xcore:
1580 case Triple::xtensa:
1581 T.setArch(UnknownArch);
1582 break;
1583
1584 case Triple::aarch64:
1585 case Triple::aarch64_be:
1586 case Triple::amdgcn:
1587 case Triple::amdil64:
1588 case Triple::bpfeb:
1589 case Triple::bpfel:
1590 case Triple::hsail64:
1591 case Triple::le64:
1593 case Triple::mips64:
1594 case Triple::mips64el:
1595 case Triple::nvptx64:
1596 case Triple::ppc64:
1597 case Triple::ppc64le:
1599 case Triple::riscv64:
1600 case Triple::sparcv9:
1601 case Triple::spir64:
1602 case Triple::spirv64:
1603 case Triple::systemz:
1604 case Triple::ve:
1605 case Triple::wasm64:
1606 case Triple::x86_64:
1607 // Already 64-bit.
1608 break;
1609
1610 case Triple::aarch64_32: T.setArch(Triple::aarch64); break;
1611 case Triple::amdil: T.setArch(Triple::amdil64); break;
1612 case Triple::arm: T.setArch(Triple::aarch64); break;
1613 case Triple::armeb: T.setArch(Triple::aarch64_be); break;
1614 case Triple::hsail: T.setArch(Triple::hsail64); break;
1615 case Triple::le32: T.setArch(Triple::le64); break;
1616 case Triple::loongarch32: T.setArch(Triple::loongarch64); break;
1617 case Triple::mips:
1618 T.setArch(Triple::mips64, getSubArch());
1619 break;
1620 case Triple::mipsel:
1621 T.setArch(Triple::mips64el, getSubArch());
1622 break;
1623 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1624 case Triple::ppc: T.setArch(Triple::ppc64); break;
1625 case Triple::ppcle: T.setArch(Triple::ppc64le); break;
1626 case Triple::renderscript32: T.setArch(Triple::renderscript64); break;
1627 case Triple::riscv32: T.setArch(Triple::riscv64); break;
1628 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1629 case Triple::spir: T.setArch(Triple::spir64); break;
1630 case Triple::spirv32:
1631 T.setArch(Triple::spirv64, getSubArch());
1632 break;
1633 case Triple::thumb: T.setArch(Triple::aarch64); break;
1634 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break;
1635 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1636 case Triple::x86: T.setArch(Triple::x86_64); break;
1637 }
1638 return T;
1639}
1640
1642 Triple T(*this);
1643 // Already big endian.
1644 if (!isLittleEndian())
1645 return T;
1646 switch (getArch()) {
1648 case Triple::amdgcn:
1649 case Triple::amdil64:
1650 case Triple::amdil:
1651 case Triple::avr:
1652 case Triple::dxil:
1653 case Triple::hexagon:
1654 case Triple::hsail64:
1655 case Triple::hsail:
1656 case Triple::kalimba:
1657 case Triple::le32:
1658 case Triple::le64:
1661 case Triple::msp430:
1662 case Triple::nvptx64:
1663 case Triple::nvptx:
1664 case Triple::r600:
1667 case Triple::riscv32:
1668 case Triple::riscv64:
1669 case Triple::shave:
1670 case Triple::spir64:
1671 case Triple::spir:
1672 case Triple::spirv32:
1673 case Triple::spirv64:
1674 case Triple::wasm32:
1675 case Triple::wasm64:
1676 case Triple::x86:
1677 case Triple::x86_64:
1678 case Triple::xcore:
1679 case Triple::ve:
1680 case Triple::csky:
1681 case Triple::xtensa:
1682
1683 // ARM is intentionally unsupported here, changing the architecture would
1684 // drop any arch suffixes.
1685 case Triple::arm:
1686 case Triple::thumb:
1687 T.setArch(UnknownArch);
1688 break;
1689
1690 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1691 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1692 case Triple::mips64el:
1693 T.setArch(Triple::mips64, getSubArch());
1694 break;
1695 case Triple::mipsel:
1696 T.setArch(Triple::mips, getSubArch());
1697 break;
1698 case Triple::ppcle: T.setArch(Triple::ppc); break;
1699 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1700 case Triple::sparcel: T.setArch(Triple::sparc); break;
1701 case Triple::tcele: T.setArch(Triple::tce); break;
1702 default:
1703 llvm_unreachable("getBigEndianArchVariant: unknown triple.");
1704 }
1705 return T;
1706}
1707
1709 Triple T(*this);
1710 if (isLittleEndian())
1711 return T;
1712
1713 switch (getArch()) {
1715 case Triple::lanai:
1716 case Triple::sparcv9:
1717 case Triple::systemz:
1718 case Triple::m68k:
1719
1720 // ARM is intentionally unsupported here, changing the architecture would
1721 // drop any arch suffixes.
1722 case Triple::armeb:
1723 case Triple::thumbeb:
1724 T.setArch(UnknownArch);
1725 break;
1726
1727 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1728 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1729 case Triple::mips64:
1730 T.setArch(Triple::mips64el, getSubArch());
1731 break;
1732 case Triple::mips:
1733 T.setArch(Triple::mipsel, getSubArch());
1734 break;
1735 case Triple::ppc: T.setArch(Triple::ppcle); break;
1736 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1737 case Triple::sparc: T.setArch(Triple::sparcel); break;
1738 case Triple::tce: T.setArch(Triple::tcele); break;
1739 default:
1740 llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
1741 }
1742 return T;
1743}
1744
1746 switch (getArch()) {
1747 case Triple::aarch64:
1748 case Triple::aarch64_32:
1749 case Triple::amdgcn:
1750 case Triple::amdil64:
1751 case Triple::amdil:
1752 case Triple::arm:
1753 case Triple::avr:
1754 case Triple::bpfel:
1755 case Triple::csky:
1756 case Triple::dxil:
1757 case Triple::hexagon:
1758 case Triple::hsail64:
1759 case Triple::hsail:
1760 case Triple::kalimba:
1761 case Triple::le32:
1762 case Triple::le64:
1765 case Triple::mips64el:
1766 case Triple::mipsel:
1767 case Triple::msp430:
1768 case Triple::nvptx64:
1769 case Triple::nvptx:
1770 case Triple::ppcle:
1771 case Triple::ppc64le:
1772 case Triple::r600:
1775 case Triple::riscv32:
1776 case Triple::riscv64:
1777 case Triple::shave:
1778 case Triple::sparcel:
1779 case Triple::spir64:
1780 case Triple::spir:
1781 case Triple::spirv32:
1782 case Triple::spirv64:
1783 case Triple::tcele:
1784 case Triple::thumb:
1785 case Triple::ve:
1786 case Triple::wasm32:
1787 case Triple::wasm64:
1788 case Triple::x86:
1789 case Triple::x86_64:
1790 case Triple::xcore:
1791 case Triple::xtensa:
1792 return true;
1793 default:
1794 return false;
1795 }
1796}
1797
1799 // ARM and Thumb triples are compatible, if subarch, vendor and OS match.
1800 if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) ||
1801 (getArch() == Triple::arm && Other.getArch() == Triple::thumb) ||
1802 (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) ||
1803 (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) {
1804 if (getVendor() == Triple::Apple)
1805 return getSubArch() == Other.getSubArch() &&
1806 getVendor() == Other.getVendor() && getOS() == Other.getOS();
1807 else
1808 return getSubArch() == Other.getSubArch() &&
1809 getVendor() == Other.getVendor() && getOS() == Other.getOS() &&
1810 getEnvironment() == Other.getEnvironment() &&
1811 getObjectFormat() == Other.getObjectFormat();
1812 }
1813
1814 // If vendor is apple, ignore the version number.
1815 if (getVendor() == Triple::Apple)
1816 return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
1817 getVendor() == Other.getVendor() && getOS() == Other.getOS();
1818
1819 return *this == Other;
1820}
1821
1822std::string Triple::merge(const Triple &Other) const {
1823 // If vendor is apple, pick the triple with the larger version number.
1824 if (getVendor() == Triple::Apple)
1825 if (Other.isOSVersionLT(*this))
1826 return str();
1827
1828 return Other.str();
1829}
1830
1831bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor,
1832 unsigned Micro) const {
1833 assert(isMacOSX() && "Not an OS X triple!");
1834
1835 // If this is OS X, expect a sane version number.
1836 if (getOS() == Triple::MacOSX)
1837 return isOSVersionLT(Major, Minor, Micro);
1838
1839 // Otherwise, compare to the "Darwin" number.
1840 if (Major == 10) {
1841 return isOSVersionLT(Minor + 4, Micro, 0);
1842 } else {
1843 assert(Major >= 11 && "Unexpected major version");
1844 return isOSVersionLT(Major - 11 + 20, Minor, Micro);
1845 }
1846}
1847
1850 return VersionTuple();
1851 switch (getOS()) {
1852 case Triple::MacOSX:
1853 // ARM64 slice is supported starting from macOS 11.0+.
1854 return VersionTuple(11, 0, 0);
1855 case Triple::IOS:
1856 // ARM64 slice is supported starting from Mac Catalyst 14 (macOS 11).
1857 // ARM64 simulators are supported for iOS 14+.
1859 return VersionTuple(14, 0, 0);
1860 // ARM64e slice is supported starting from iOS 14.
1861 if (isArm64e())
1862 return VersionTuple(14, 0, 0);
1863 break;
1864 case Triple::TvOS:
1865 // ARM64 simulators are supported for tvOS 14+.
1867 return VersionTuple(14, 0, 0);
1868 break;
1869 case Triple::WatchOS:
1870 // ARM64 simulators are supported for watchOS 7+.
1872 return VersionTuple(7, 0, 0);
1873 break;
1874 case Triple::DriverKit:
1875 return VersionTuple(20, 0, 0);
1876 default:
1877 break;
1878 }
1879 return VersionTuple();
1880}
1881
1883 const VersionTuple &Version) {
1884 switch (OSKind) {
1885 case MacOSX:
1886 // macOS 10.16 is canonicalized to macOS 11.
1887 if (Version == VersionTuple(10, 16))
1888 return VersionTuple(11, 0);
1889 [[fallthrough]];
1890 default:
1891 return Version;
1892 }
1893}
1894
1895// HLSL triple environment orders are relied on in the front end
1896static_assert(Triple::Vertex - Triple::Pixel == 1,
1897 "incorrect HLSL stage order");
1898static_assert(Triple::Geometry - Triple::Pixel == 2,
1899 "incorrect HLSL stage order");
1900static_assert(Triple::Hull - Triple::Pixel == 3,
1901 "incorrect HLSL stage order");
1902static_assert(Triple::Domain - Triple::Pixel == 4,
1903 "incorrect HLSL stage order");
1904static_assert(Triple::Compute - Triple::Pixel == 5,
1905 "incorrect HLSL stage order");
1906static_assert(Triple::Library - Triple::Pixel == 6,
1907 "incorrect HLSL stage order");
1908static_assert(Triple::RayGeneration - Triple::Pixel == 7,
1909 "incorrect HLSL stage order");
1910static_assert(Triple::Intersection - Triple::Pixel == 8,
1911 "incorrect HLSL stage order");
1912static_assert(Triple::AnyHit - Triple::Pixel == 9,
1913 "incorrect HLSL stage order");
1914static_assert(Triple::ClosestHit - Triple::Pixel == 10,
1915 "incorrect HLSL stage order");
1916static_assert(Triple::Miss - Triple::Pixel == 11,
1917 "incorrect HLSL stage order");
1918static_assert(Triple::Callable - Triple::Pixel == 12,
1919 "incorrect HLSL stage order");
1920static_assert(Triple::Mesh - Triple::Pixel == 13,
1921 "incorrect HLSL stage order");
1922static_assert(Triple::Amplification - Triple::Pixel == 14,
1923 "incorrect HLSL stage order");
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
std::string Name
Load MIR Sample Profile
static bool startswith(StringRef Magic, const char(&S)[N])
Definition: Magic.cpp:28
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file contains some functions that are useful when dealing with strings.
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName)
Definition: Triple.cpp:602
static VersionTuple parseVersionFromName(StringRef Name)
Definition: Triple.cpp:1201
static Triple::ObjectFormatType getDefaultFormat(const Triple &T)
Definition: Triple.cpp:797
static Triple::ArchType parseARMArch(StringRef ArchName)
Definition: Triple.cpp:384
static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch)
Definition: Triple.cpp:1395
static Triple::OSType parseOS(StringRef OSName)
Definition: Triple.cpp:558
static Triple::ArchType parseBPFArch(StringRef ArchName)
Definition: Triple.cpp:298
static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind)
Definition: Triple.cpp:773
static Triple::SubArchType parseSubArch(StringRef SubArchName)
Definition: Triple.cpp:660
static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName)
Definition: Triple.cpp:646
static Triple::ArchType parseArch(StringRef ArchName)
Definition: Triple.cpp:449
static Triple::VendorType parseVendor(StringRef VendorName)
Definition: Triple.cpp:538
Defines the llvm::VersionTuple class, which represents a version in the form major[....
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
size_t size() const
Definition: SmallVector.h:91
void resize(size_type N)
Definition: SmallVector.h:642
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:688
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:559
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
bool startswith(StringRef Prefix) const
Definition: StringRef.h:261
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition: StringRef.h:623
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:164
bool endswith(StringRef Suffix) const
Definition: StringRef.h:277
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:44
StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:69
R Default(T Value)
Definition: StringSwitch.h:182
StringSwitch & StartsWith(StringLiteral S, T Value)
Definition: StringSwitch.h:83
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, T Value)
Definition: StringSwitch.h:90
StringSwitch & EndsWith(StringLiteral S, T Value)
Definition: StringSwitch.h:76
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
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:1831
VersionTuple getOSVersion() const
Parse the version number from the OS name component of the triple, if present.
Definition: Triple.cpp:1216
StringRef getVendorName() const
Get the vendor (second) component of the triple.
Definition: Triple.cpp:1179
VersionTuple getWatchOSVersion() const
Parse the version number as with getOSVersion.
Definition: Triple.cpp:1296
void setArchName(StringRef Str)
Set the architecture (first) component of the triple by name.
Definition: Triple.cpp:1363
void setObjectFormat(ObjectFormatType Kind)
Set the object file format.
Definition: Triple.cpp:1355
llvm::Triple get32BitArchVariant() const
Form a triple with a 32-bit variant of the current architecture.
Definition: Triple.cpp:1481
Triple()=default
Default constructor is the same as an empty string and leaves all triple fields unknown.
@ RayGeneration
Definition: Triple.h:268
@ UnknownEnvironment
Definition: Triple.h:229
@ ClosestHit
Definition: Triple.h:271
@ MuslEABIHF
Definition: Triple.h:247
@ Amplification
Definition: Triple.h:275
@ Intersection
Definition: Triple.h:269
std::string normalize() const
Return the normalized form of this triple's string.
Definition: Triple.h:348
llvm::Triple getLittleEndianArchVariant() const
Form a triple with a little endian variant of the current architecture.
Definition: Triple.cpp:1708
static StringRef getVendorTypeName(VendorType Kind)
Get the canonical name for the Kind vendor.
Definition: Triple.cpp:181
ObjectFormatType getObjectFormat() const
Get the object format for this triple.
Definition: Triple.h:381
SubArchType getSubArch() const
get the parsed subarchitecture type for this triple.
Definition: Triple.h:358
bool isArm64e() const
Tests whether the target is the Apple "arm64e" AArch64 subarch.
Definition: Triple.h:931
void setVendorName(StringRef Str)
Set the vendor (second) component of the triple by name.
Definition: Triple.cpp:1374
@ HermitCore
Definition: Triple.h:221
@ ShaderModel
Definition: Triple.h:225
@ Emscripten
Definition: Triple.h:224
void setOSAndEnvironmentName(StringRef Str)
Set the operating system and optional environment components with a single string.
Definition: Triple.cpp:1391
llvm::Triple get64BitArchVariant() const
Form a triple with a 64-bit variant of the current architecture.
Definition: Triple.cpp:1561
bool isLittleEndian() const
Tests whether the target triple is little endian.
Definition: Triple.cpp:1745
void setEnvironment(EnvironmentType Kind)
Set the environment (fourth) component of the triple to a known type.
Definition: Triple.cpp:1347
StringRef getOSName() const
Get the operating system (third) component of the triple.
Definition: Triple.cpp:1184
@ loongarch32
Definition: Triple.h:61
@ renderscript64
Definition: Triple.h:107
@ UnknownArch
Definition: Triple.h:47
@ aarch64_be
Definition: Triple.h:52
@ loongarch64
Definition: Triple.h:62
@ renderscript32
Definition: Triple.h:106
@ mips64el
Definition: Triple.h:67
@ aarch64_32
Definition: Triple.h:53
void setTriple(const Twine &Str)
Set all components to the new triple Str.
Definition: Triple.cpp:1331
OSType getOS() const
Get the parsed operating system type of this triple.
Definition: Triple.h:364
VersionTuple getEnvironmentVersion() const
Parse the version number from the OS name component of the triple, if present.
Definition: Triple.cpp:1207
static ArchType getArchTypeForLLVMName(StringRef Str)
The canonical type for the given LLVM architecture name (e.g., "x86").
Definition: Triple.cpp:313
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:355
StringRef getEnvironmentName() const
Get the optional environment (fourth) component of the triple, or "" if empty.
Definition: Triple.cpp:1190
bool isSimulatorEnvironment() const
Definition: Triple.h:522
const std::string & str() const
Definition: Triple.h:414
EnvironmentType getEnvironment() const
Get the parsed environment type of this triple.
Definition: Triple.h:372
VersionTuple getDriverKitVersion() const
Parse the version number as with getOSVersion.
Definition: Triple.cpp:1319
static StringRef getArchTypeName(ArchType Kind)
Get the canonical name for the Kind architecture.
Definition: Triple.cpp:23
static StringRef getOSTypeName(OSType Kind)
Get the canonical name for the Kind operating system.
Definition: Triple.cpp:204
ObjectFormatType
Definition: Triple.h:279
@ DXContainer
Definition: Triple.h:283
@ UnknownObjectFormat
Definition: Triple.h:280
std::string merge(const Triple &Other) const
Merge target triples.
Definition: Triple.cpp:1822
@ UnknownVendor
Definition: Triple.h:167
@ OpenEmbedded
Definition: Triple.h:182
@ ImaginationTechnologies
Definition: Triple.h:174
@ MipsTechnologies
Definition: Triple.h:175
VersionTuple getMinimumSupportedOSVersion() const
Some platforms have different minimum supported OS versions that varies by the architecture specified...
Definition: Triple.cpp:1848
bool isArch64Bit() const
Test whether the architecture is 64-bit.
Definition: Triple.cpp:1469
StringRef getOSAndEnvironmentName() const
Get the operating system and optional environment components as a single string (separated by a '-' i...
Definition: Triple.cpp:1196
@ ARMSubArch_v6t2
Definition: Triple.h:142
@ MipsSubArch_r6
Definition: Triple.h:154
@ ARMSubArch_v7
Definition: Triple.h:133
@ ARMSubArch_v8m_mainline
Definition: Triple.h:131
@ ARMSubArch_v8r
Definition: Triple.h:129
@ ARMSubArch_v9_1a
Definition: Triple.h:117
@ SPIRVSubArch_v10
Definition: Triple.h:159
@ SPIRVSubArch_v13
Definition: Triple.h:162
@ ARMSubArch_v7k
Definition: Triple.h:137
@ ARMSubArch_v8_7a
Definition: Triple.h:121
@ ARMSubArch_v8
Definition: Triple.h:128
@ ARMSubArch_v8_1a
Definition: Triple.h:127
@ ARMSubArch_v9_2a
Definition: Triple.h:116
@ SPIRVSubArch_v15
Definition: Triple.h:164
@ ARMSubArch_v7m
Definition: Triple.h:135
@ ARMSubArch_v6k
Definition: Triple.h:141
@ ARMSubArch_v5
Definition: Triple.h:143
@ AArch64SubArch_arm64e
Definition: Triple.h:147
@ ARMSubArch_v6
Definition: Triple.h:139
@ ARMSubArch_v7ve
Definition: Triple.h:138
@ ARMSubArch_v8m_baseline
Definition: Triple.h:130
@ ARMSubArch_v8_8a
Definition: Triple.h:120
@ ARMSubArch_v8_2a
Definition: Triple.h:126
@ ARMSubArch_v7s
Definition: Triple.h:136
@ KalimbaSubArch_v3
Definition: Triple.h:150
@ ARMSubArch_v8_4a
Definition: Triple.h:124
@ ARMSubArch_v8_9a
Definition: Triple.h:119
@ ARMSubArch_v7em
Definition: Triple.h:134
@ SPIRVSubArch_v12
Definition: Triple.h:161
@ SPIRVSubArch_v14
Definition: Triple.h:163
@ KalimbaSubArch_v4
Definition: Triple.h:151
@ ARMSubArch_v8_1m_mainline
Definition: Triple.h:132
@ ARMSubArch_v8_3a
Definition: Triple.h:125
@ AArch64SubArch_arm64ec
Definition: Triple.h:148
@ ARMSubArch_v8_6a
Definition: Triple.h:122
@ ARMSubArch_v5te
Definition: Triple.h:144
@ KalimbaSubArch_v5
Definition: Triple.h:152
@ ARMSubArch_v4t
Definition: Triple.h:145
@ ARMSubArch_v9_4a
Definition: Triple.h:114
@ ARMSubArch_v8_5a
Definition: Triple.h:123
@ ARMSubArch_v6m
Definition: Triple.h:140
@ ARMSubArch_v9_3a
Definition: Triple.h:115
@ ARMSubArch_v9
Definition: Triple.h:118
@ SPIRVSubArch_v11
Definition: Triple.h:160
@ PPCSubArch_spe
Definition: Triple.h:156
bool getMacOSXVersion(VersionTuple &Version) const
Parse the version number as with getOSVersion and then translate generic "darwin" versions to the cor...
Definition: Triple.cpp:1228
bool isMacOSX() const
Is this a Mac OS X triple.
Definition: Triple.h:485
void setEnvironmentName(StringRef Str)
Set the optional environment (fourth) component of the triple by name.
Definition: Triple.cpp:1386
void setOS(OSType Kind)
Set the operating system (third) component of the triple to a known type.
Definition: Triple.cpp:1343
void setOSName(StringRef Str)
Set the operating system (third) component of the triple by name.
Definition: Triple.cpp:1378
VendorType getVendor() const
Get the parsed vendor type of this triple.
Definition: Triple.h:361
static StringRef getEnvironmentTypeName(EnvironmentType Kind)
Get the canonical name for the Kind environment.
Definition: Triple.cpp:251
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:463
static VersionTuple getCanonicalVersionForOS(OSType OSKind, const VersionTuple &Version)
Returns a canonicalized OS version number for the specified OS.
Definition: Triple.cpp:1882
StringRef getArchName() const
Get the architecture (first) component of the triple.
Definition: Triple.cpp:1147
bool isMacCatalystEnvironment() const
Definition: Triple.h:526
bool isArch16Bit() const
Test whether the architecture is 16-bit.
Definition: Triple.cpp:1477
llvm::Triple getBigEndianArchVariant() const
Form a triple with a big endian variant of the current architecture.
Definition: Triple.cpp:1641
VersionTuple getiOSVersion() const
Parse the version number as with getOSVersion.
Definition: Triple.cpp:1271
bool isArch32Bit() const
Test whether the architecture is 32-bit.
Definition: Triple.cpp:1473
bool isCompatibleWith(const Triple &Other) const
Test whether target triples are compatible.
Definition: Triple.cpp:1798
bool hasEnvironment() const
Does this triple have the optional environment (fourth) component?
Definition: Triple.h:367
static StringRef getArchTypePrefix(ArchType Kind)
Get the "prefix" canonical name for the Kind architecture.
Definition: Triple.cpp:92
void setArch(ArchType Kind, SubArchType SubArch=NoSubArch)
Set the architecture (first) component of the triple to a known type.
Definition: Triple.cpp:1335
void setVendor(VendorType Kind)
Set the vendor (second) component of the triple to a known type.
Definition: Triple.cpp:1339
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:31
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
StringRef getCanonicalArchName(StringRef Arch)
MArch is expected to be of the form (arm|thumb)?(eb)?(v.
ISAKind parseArchISA(StringRef Arch)
ArchKind parseArch(StringRef Arch)
ProfileKind parseArchProfile(StringRef Arch)
unsigned parseArchVersion(StringRef Arch)
EndianKind parseArchEndian(StringRef Arch)
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
static const bool IsLittleEndianHost
Definition: SwapByteOrder.h:67
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:853