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
9#include "llvm/TargetParser/Triple.h"
10#include "llvm/ADT/SmallString.h"
11#include "llvm/ADT/StringExtras.h"
12#include "llvm/ADT/StringSwitch.h"
13#include "llvm/Support/ErrorHandling.h"
14#include "llvm/Support/SwapByteOrder.h"
15#include "llvm/Support/VersionTuple.h"
16#include "llvm/TargetParser/ARMTargetParser.h"
17#include "llvm/TargetParser/ARMTargetParserCommon.h"
18#include "llvm/TargetParser/Host.h"
19#include <cassert>
20#include <cstring>
21using namespace llvm;
22
23StringRef Triple::getArchTypeName(ArchType Kind) {
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
92StringRef Triple::getArchTypePrefix(ArchType Kind) {
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
181StringRef Triple::getVendorTypeName(VendorType Kind) {
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
204StringRef Triple::getOSTypeName(OSType Kind) {
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
251StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
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
298static Triple::ArchType parseBPFArch(StringRef ArchName) {
299 if (ArchName.equals("bpf")) {
300 if (sys::IsLittleEndianHost)
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
313Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
314 Triple::ArchType BPFArch(parseBPFArch(Name));
315 return StringSwitch<Triple::ArchType>(Name)
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)
381 .Default(UnknownArch);
382}
383
384static Triple::ArchType parseARMArch(StringRef ArchName) {
385 ARM::ISAKind ISA = ARM::parseArchISA(ArchName);
386 ARM::EndianKind ENDIAN = ARM::parseArchEndian(ArchName);
387
388 Triple::ArchType arch = Triple::UnknownArch;
389 switch (ENDIAN) {
390 case ARM::EndianKind::LITTLE: {
391 switch (ISA) {
392 case ARM::ISAKind::ARM:
393 arch = Triple::arm;
394 break;
395 case ARM::ISAKind::THUMB:
396 arch = Triple::thumb;
397 break;
398 case ARM::ISAKind::AARCH64:
399 arch = Triple::aarch64;
400 break;
401 case ARM::ISAKind::INVALID:
402 break;
403 }
404 break;
405 }
406 case ARM::EndianKind::BIG: {
407 switch (ISA) {
408 case ARM::ISAKind::ARM:
409 arch = Triple::armeb;
410 break;
411 case ARM::ISAKind::THUMB:
412 arch = Triple::thumbeb;
413 break;
414 case ARM::ISAKind::AARCH64:
415 arch = Triple::aarch64_be;
416 break;
417 case ARM::ISAKind::INVALID:
418 break;
419 }
420 break;
421 }
422 case ARM::EndianKind::INVALID: {
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
437 ARM::ProfileKind Profile = ARM::parseArchProfile(ArchName);
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
449static Triple::ArchType parseArch(StringRef ArchName) {
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",
479 Triple::mipsel)
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)
523 .Default(Triple::UnknownArch);
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
538static Triple::VendorType parseVendor(StringRef VendorName) {
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)
546 .Case("img", Triple::ImaginationTechnologies)
547 .Case("mti", Triple::MipsTechnologies)
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)
554 .Case("oe", Triple::OpenEmbedded)
555 .Default(Triple::UnknownVendor);
556}
557
558static Triple::OSType parseOS(StringRef OSName) {
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)
594 .StartsWith("hermit", Triple::HermitCore)
595 .StartsWith("hurd", Triple::Hurd)
596 .StartsWith("wasi", Triple::WASI)
597 .StartsWith("emscripten", Triple::Emscripten)
598 .StartsWith("shadermodel", Triple::ShaderModel)
599 .Default(Triple::UnknownOS);
600}
601
602static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
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)
643 .Default(Triple::UnknownEnvironment);
644}
645
646static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
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)
657 .Default(Triple::UnknownObjectFormat);
658}
659
660static Triple::SubArchType parseSubArch(StringRef SubArchName) {
661 if (SubArchName.startswith("mips") &&
662 (SubArchName.endswith("r6el") || SubArchName.endswith("r6")))
663 return Triple::MipsSubArch_r6;
664
665 if (SubArchName == "powerpcspe")
666 return Triple::PPCSubArch_spe;
667
668 if (SubArchName == "arm64e")
669 return Triple::AArch64SubArch_arm64e;
670
671 if (SubArchName == "arm64ec")
672 return Triple::AArch64SubArch_arm64ec;
673
674 if (SubArchName.startswith("spirv"))
675 return StringSwitch<Triple::SubArchType>(SubArchName)
676 .EndsWith("v1.0", Triple::SPIRVSubArch_v10)
677 .EndsWith("v1.1", Triple::SPIRVSubArch_v11)
678 .EndsWith("v1.2", Triple::SPIRVSubArch_v12)
679 .EndsWith("v1.3", Triple::SPIRVSubArch_v13)
680 .EndsWith("v1.4", Triple::SPIRVSubArch_v14)
681 .EndsWith("v1.5", Triple::SPIRVSubArch_v15)
682 .Default(Triple::NoSubArch);
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)
689 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
690 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
691 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
692 .Default(Triple::NoSubArch);
693
694 // ARM sub arch.
695 switch(ARM::parseArch(ARMSubArch)) {
696 case ARM::ArchKind::ARMV4:
697 return Triple::NoSubArch;
698 case ARM::ArchKind::ARMV4T:
699 return Triple::ARMSubArch_v4t;
700 case ARM::ArchKind::ARMV5T:
701 return Triple::ARMSubArch_v5;
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:
707 return Triple::ARMSubArch_v5te;
708 case ARM::ArchKind::ARMV6:
709 return Triple::ARMSubArch_v6;
710 case ARM::ArchKind::ARMV6K:
711 case ARM::ArchKind::ARMV6KZ:
712 return Triple::ARMSubArch_v6k;
713 case ARM::ArchKind::ARMV6T2:
714 return Triple::ARMSubArch_v6t2;
715 case ARM::ArchKind::ARMV6M:
716 return Triple::ARMSubArch_v6m;
717 case ARM::ArchKind::ARMV7A:
718 case ARM::ArchKind::ARMV7R:
719 return Triple::ARMSubArch_v7;
720 case ARM::ArchKind::ARMV7VE:
721 return Triple::ARMSubArch_v7ve;
722 case ARM::ArchKind::ARMV7K:
723 return Triple::ARMSubArch_v7k;
724 case ARM::ArchKind::ARMV7M:
725 return Triple::ARMSubArch_v7m;
726 case ARM::ArchKind::ARMV7S:
727 return Triple::ARMSubArch_v7s;
728 case ARM::ArchKind::ARMV7EM:
729 return Triple::ARMSubArch_v7em;
730 case ARM::ArchKind::ARMV8A:
731 return Triple::ARMSubArch_v8;
732 case ARM::ArchKind::ARMV8_1A:
733 return Triple::ARMSubArch_v8_1a;
734 case ARM::ArchKind::ARMV8_2A:
735 return Triple::ARMSubArch_v8_2a;
736 case ARM::ArchKind::ARMV8_3A:
737 return Triple::ARMSubArch_v8_3a;
738 case ARM::ArchKind::ARMV8_4A:
739 return Triple::ARMSubArch_v8_4a;
740 case ARM::ArchKind::ARMV8_5A:
741 return Triple::ARMSubArch_v8_5a;
742 case ARM::ArchKind::ARMV8_6A:
743 return Triple::ARMSubArch_v8_6a;
744 case ARM::ArchKind::ARMV8_7A:
745 return Triple::ARMSubArch_v8_7a;
746 case ARM::ArchKind::ARMV8_8A:
747 return Triple::ARMSubArch_v8_8a;
748 case ARM::ArchKind::ARMV8_9A:
749 return Triple::ARMSubArch_v8_9a;
750 case ARM::ArchKind::ARMV9A:
751 return Triple::ARMSubArch_v9;
752 case ARM::ArchKind::ARMV9_1A:
753 return Triple::ARMSubArch_v9_1a;
754 case ARM::ArchKind::ARMV9_2A:
755 return Triple::ARMSubArch_v9_2a;
756 case ARM::ArchKind::ARMV9_3A:
757 return Triple::ARMSubArch_v9_3a;
758 case ARM::ArchKind::ARMV9_4A:
759 return Triple::ARMSubArch_v9_4a;
760 case ARM::ArchKind::ARMV8R:
761 return Triple::ARMSubArch_v8r;
762 case ARM::ArchKind::ARMV8MBaseline:
763 return Triple::ARMSubArch_v8m_baseline;
764 case ARM::ArchKind::ARMV8MMainline:
765 return Triple::ARMSubArch_v8m_mainline;
766 case ARM::ArchKind::ARMV8_1MMainline:
767 return Triple::ARMSubArch_v8_1m_mainline;
768 default:
769 return Triple::NoSubArch;
770 }
771}
772
773static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
774 switch (Kind) {
775 case Triple::UnknownObjectFormat:
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";
789 case Triple::DXContainer:
790 return "dxcontainer";
791 case Triple::SPIRV:
792 return "spirv";
793 }
794 llvm_unreachable("unknown object format type");
795}
796
797static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
798 switch (T.getArch()) {
799 case Triple::UnknownArch:
800 case Triple::aarch64:
801 case Triple::aarch64_32:
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
812 case Triple::aarch64_be:
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:
829 case Triple::loongarch32:
830 case Triple::loongarch64:
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:
842 case Triple::renderscript32:
843 case Triple::renderscript64:
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.
889Triple::Triple(const Twine &Str)
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 =
910 StringSwitch<Triple::EnvironmentType>(Components[0])
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)
916 .Default(UnknownEnvironment);
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 }
983 EnvironmentType Environment = UnknownEnvironment;
984 if (Components.size() > 3)
985 Environment = parseEnvironment(Components[3]);
986 ObjectFormatType ObjectFormat = UnknownObjectFormat;
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
1147StringRef Triple::getArchName() const {
1148 return StringRef(Data).split('-').first; // Isolate first component
1149}
1150
1151StringRef Triple::getArchName(ArchType Kind, SubArchType SubArch) const {
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
1179StringRef Triple::getVendorName() const {
1180 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
1181 return Tmp.split('-').first; // Isolate second component
1182}
1183
1184StringRef Triple::getOSName() const {
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
1190StringRef Triple::getEnvironmentName() const {
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
1196StringRef Triple::getOSAndEnvironmentName() const {
1197 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
1198 return Tmp.split('-').second; // Strip second component
1199}
1200
1201static VersionTuple parseVersionFromName(StringRef Name) {
1202 VersionTuple Version;
1203 Version.tryParse(Name);
1204 return Version.withoutBuild();
1205}
1206
1207VersionTuple Triple::getEnvironmentVersion() const {
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
1216VersionTuple Triple::getOSVersion() const {
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
1228bool Triple::getMacOSXVersion(VersionTuple &Version) const {
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
1271VersionTuple Triple::getiOSVersion() const {
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
1296VersionTuple Triple::getWatchOSVersion() const {
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
1319VersionTuple Triple::getDriverKitVersion() const {
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
1335void Triple::setArch(ArchType Kind, SubArchType SubArch) {
1336 setArchName(getArchName(Kind, SubArch));
1337}
1338
1339void Triple::setVendor(VendorType Kind) {
1340 setVendorName(getVendorTypeName(Kind));
1341}
1342
1343void Triple::setOS(OSType Kind) {
1344 setOSName(getOSTypeName(Kind));
1345}
1346
1347void Triple::setEnvironment(EnvironmentType Kind) {
1348 if (ObjectFormat == getDefaultFormat(*this))
1349 return setEnvironmentName(getEnvironmentTypeName(Kind));
1350
1351 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1352 getObjectFormatTypeName(ObjectFormat)).str());
1353}
1354
1355void Triple::setObjectFormat(ObjectFormatType Kind) {
1356 if (Environment == UnknownEnvironment)
1357 return setEnvironmentName(getObjectFormatTypeName(Kind));
1358
1359 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1360 getObjectFormatTypeName(Kind)).str());
1361}
1362
1363void Triple::setArchName(StringRef Str) {
1364 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1365 SmallString<64> Triple;
1366 Triple += Str;
1367 Triple += "-";
1368 Triple += getVendorName();
1369 Triple += "-";
1370 Triple += getOSAndEnvironmentName();
1371 setTriple(Triple);
1372}
1373
1374void Triple::setVendorName(StringRef Str) {
1375 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1376}
1377
1378void Triple::setOSName(StringRef Str) {
1379 if (hasEnvironment())
1380 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1381 "-" + getEnvironmentName());
1382 else
1383 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1384}
1385
1386void Triple::setEnvironmentName(StringRef Str) {
1387 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1388 "-" + Str);
1389}
1390
1391void Triple::setOSAndEnvironmentName(StringRef Str) {
1392 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1393}
1394
1395static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1396 switch (Arch) {
1397 case llvm::Triple::UnknownArch:
1398 return 0;
1399
1400 case llvm::Triple::avr:
1401 case llvm::Triple::msp430:
1402 return 16;
1403
1404 case llvm::Triple::aarch64_32:
1405 case llvm::Triple::amdil:
1406 case llvm::Triple::arc:
1407 case llvm::Triple::arm:
1408 case llvm::Triple::armeb:
1409 case llvm::Triple::csky:
1410 case llvm::Triple::dxil:
1411 case llvm::Triple::hexagon:
1412 case llvm::Triple::hsail:
1413 case llvm::Triple::kalimba:
1414 case llvm::Triple::lanai:
1415 case llvm::Triple::le32:
1416 case llvm::Triple::loongarch32:
1417 case llvm::Triple::m68k:
1418 case llvm::Triple::mips:
1419 case llvm::Triple::mipsel:
1420 case llvm::Triple::nvptx:
1421 case llvm::Triple::ppc:
1422 case llvm::Triple::ppcle:
1423 case llvm::Triple::r600:
1424 case llvm::Triple::renderscript32:
1425 case llvm::Triple::riscv32:
1426 case llvm::Triple::shave:
1427 case llvm::Triple::sparc:
1428 case llvm::Triple::sparcel:
1429 case llvm::Triple::spir:
1430 case llvm::Triple::spirv32:
1431 case llvm::Triple::tce:
1432 case llvm::Triple::tcele:
1433 case llvm::Triple::thumb:
1434 case llvm::Triple::thumbeb:
1435 case llvm::Triple::wasm32:
1436 case llvm::Triple::x86:
1437 case llvm::Triple::xcore:
1438 case llvm::Triple::xtensa:
1439 return 32;
1440
1441 case llvm::Triple::aarch64:
1442 case llvm::Triple::aarch64_be:
1443 case llvm::Triple::amdgcn:
1444 case llvm::Triple::amdil64:
1445 case llvm::Triple::bpfeb:
1446 case llvm::Triple::bpfel:
1447 case llvm::Triple::hsail64:
1448 case llvm::Triple::le64:
1449 case llvm::Triple::loongarch64:
1450 case llvm::Triple::mips64:
1451 case llvm::Triple::mips64el:
1452 case llvm::Triple::nvptx64:
1453 case llvm::Triple::ppc64:
1454 case llvm::Triple::ppc64le:
1455 case llvm::Triple::renderscript64:
1456 case llvm::Triple::riscv64:
1457 case llvm::Triple::sparcv9:
1458 case llvm::Triple::spir64:
1459 case llvm::Triple::spirv64:
1460 case llvm::Triple::systemz:
1461 case llvm::Triple::ve:
1462 case llvm::Triple::wasm64:
1463 case llvm::Triple::x86_64:
1464 return 64;
1465 }
1466 llvm_unreachable("Invalid architecture value");
1467}
1468
1469bool Triple::isArch64Bit() const {
1470 return getArchPointerBitWidth(getArch()) == 64;
1471}
1472
1473bool Triple::isArch32Bit() const {
1474 return getArchPointerBitWidth(getArch()) == 32;
1475}
1476
1477bool Triple::isArch16Bit() const {
1478 return getArchPointerBitWidth(getArch()) == 16;
1479}
1480
1481Triple Triple::get32BitArchVariant() const {
1482 Triple T(*this);
1483 switch (getArch()) {
1484 case Triple::UnknownArch:
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:
1507 case Triple::loongarch32:
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:
1515 case Triple::renderscript32:
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
1561Triple Triple::get64BitArchVariant() const {
1562 Triple T(*this);
1563 switch (getArch()) {
1564 case Triple::UnknownArch:
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:
1592 case Triple::loongarch64:
1593 case Triple::mips64:
1594 case Triple::mips64el:
1595 case Triple::nvptx64:
1596 case Triple::ppc64:
1597 case Triple::ppc64le:
1598 case Triple::renderscript64:
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
1641Triple Triple::getBigEndianArchVariant() const {
1642 Triple T(*this);
1643 // Already big endian.
1644 if (!isLittleEndian())
1645 return T;
1646 switch (getArch()) {
1647 case Triple::UnknownArch:
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:
1659 case Triple::loongarch32:
1660 case Triple::loongarch64:
1661 case Triple::msp430:
1662 case Triple::nvptx64:
1663 case Triple::nvptx:
1664 case Triple::r600:
1665 case Triple::renderscript32:
1666 case Triple::renderscript64:
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
1708Triple Triple::getLittleEndianArchVariant() const {
1709 Triple T(*this);
1710 if (isLittleEndian())
1711 return T;
1712
1713 switch (getArch()) {
1714 case Triple::UnknownArch:
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
1745bool Triple::isLittleEndian() const {
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:
1763 case Triple::loongarch32:
1764 case Triple::loongarch64:
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:
1773 case Triple::renderscript32:
1774 case Triple::renderscript64:
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
1798bool Triple::isCompatibleWith(const Triple &Other) const {
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
1848VersionTuple Triple::getMinimumSupportedOSVersion() const {
1849 if (getVendor() != Triple::Apple || getArch() != Triple::aarch64)
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+.
1858 if (isMacCatalystEnvironment() || isSimulatorEnvironment())
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+.
1866 if (isSimulatorEnvironment())
1867 return VersionTuple(14, 0, 0);
1868 break;
1869 case Triple::WatchOS:
1870 // ARM64 simulators are supported for watchOS 7+.
1871 if (isSimulatorEnvironment())
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
1882VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind,
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");
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:347
Name
std::string Name
Definition: ELFObjHandler.cpp:77
Profile
Load MIR Sample Profile
Definition: MIRSampleProfile.cpp:71
startswith
static bool startswith(StringRef Magic, const char(&S)[N])
Definition: Magic.cpp:28
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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...
parseEnvironment
static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName)
Definition: Triple.cpp:602
parseVersionFromName
static VersionTuple parseVersionFromName(StringRef Name)
Definition: Triple.cpp:1201
getDefaultFormat
static Triple::ObjectFormatType getDefaultFormat(const Triple &T)
Definition: Triple.cpp:797
parseARMArch
static Triple::ArchType parseARMArch(StringRef ArchName)
Definition: Triple.cpp:384
getArchPointerBitWidth
static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch)
Definition: Triple.cpp:1395
parseOS
static Triple::OSType parseOS(StringRef OSName)
Definition: Triple.cpp:558
parseBPFArch
static Triple::ArchType parseBPFArch(StringRef ArchName)
Definition: Triple.cpp:298
getObjectFormatTypeName
static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind)
Definition: Triple.cpp:773
parseSubArch
static Triple::SubArchType parseSubArch(StringRef SubArchName)
Definition: Triple.cpp:660
parseFormat
static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName)
Definition: Triple.cpp:646
parseArch
static Triple::ArchType parseArch(StringRef ArchName)
Definition: Triple.cpp:449
parseVendor
static Triple::VendorType parseVendor(StringRef VendorName)
Definition: Triple.cpp:538
VersionTuple.h
Defines the llvm::VersionTuple class, which represents a version in the form major[....
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:91
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:642
llvm::SmallVectorTemplateBase::push_back
void push_back(const T &Elt)
Definition: SmallVector.h:416
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
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:688
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:559
llvm::StringRef::empty
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
llvm::StringRef::size
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
llvm::StringRef::startswith
bool startswith(StringRef Prefix) const
Definition: StringRef.h:261
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:623
llvm::StringRef::equals
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:164
llvm::StringRef::endswith
bool endswith(StringRef Suffix) const
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:1831
llvm::Triple::getOSVersion
VersionTuple getOSVersion() const
Parse the version number from the OS name component of the triple, if present.
Definition: Triple.cpp:1216
llvm::Triple::getVendorName
StringRef getVendorName() const
Get the vendor (second) component of the triple.
Definition: Triple.cpp:1179
llvm::Triple::getWatchOSVersion
VersionTuple getWatchOSVersion() const
Parse the version number as with getOSVersion.
Definition: Triple.cpp:1296
llvm::Triple::setArchName
void setArchName(StringRef Str)
Set the architecture (first) component of the triple by name.
Definition: Triple.cpp:1363
llvm::Triple::setObjectFormat
void setObjectFormat(ObjectFormatType Kind)
Set the object file format.
Definition: Triple.cpp:1355
llvm::Triple::get32BitArchVariant
llvm::Triple get32BitArchVariant() const
Form a triple with a 32-bit variant of the current architecture.
Definition: Triple.cpp:1481
llvm::Triple::Triple
Triple()=default
Default constructor is the same as an empty string and leaves all triple fields unknown.
llvm::Triple::RayGeneration
@ RayGeneration
Definition: Triple.h:268
llvm::Triple::UnknownEnvironment
@ UnknownEnvironment
Definition: Triple.h:229
llvm::Triple::ClosestHit
@ ClosestHit
Definition: Triple.h:271
llvm::Triple::MuslEABIHF
@ MuslEABIHF
Definition: Triple.h:247
llvm::Triple::Amplification
@ Amplification
Definition: Triple.h:275
llvm::Triple::Intersection
@ Intersection
Definition: Triple.h:269
llvm::Triple::normalize
std::string normalize() const
Return the normalized form of this triple's string.
Definition: Triple.h:348
llvm::Triple::getLittleEndianArchVariant
llvm::Triple getLittleEndianArchVariant() const
Form a triple with a little endian variant of the current architecture.
Definition: Triple.cpp:1708
llvm::Triple::getVendorTypeName
static StringRef getVendorTypeName(VendorType Kind)
Get the canonical name for the Kind vendor.
Definition: Triple.cpp:181
llvm::Triple::getObjectFormat
ObjectFormatType getObjectFormat() const
Get the object format for this triple.
Definition: Triple.h:381
llvm::Triple::getSubArch
SubArchType getSubArch() const
get the parsed subarchitecture type for this triple.
Definition: Triple.h:358
llvm::Triple::isArm64e
bool isArm64e() const
Tests whether the target is the Apple "arm64e" AArch64 subarch.
Definition: Triple.h:931
llvm::Triple::setVendorName
void setVendorName(StringRef Str)
Set the vendor (second) component of the triple by name.
Definition: Triple.cpp:1374
llvm::Triple::HermitCore
@ HermitCore
Definition: Triple.h:221
llvm::Triple::ShaderModel
@ ShaderModel
Definition: Triple.h:225
llvm::Triple::Emscripten
@ Emscripten
Definition: Triple.h:224
llvm::Triple::setOSAndEnvironmentName
void setOSAndEnvironmentName(StringRef Str)
Set the operating system and optional environment components with a single string.
Definition: Triple.cpp:1391
llvm::Triple::get64BitArchVariant
llvm::Triple get64BitArchVariant() const
Form a triple with a 64-bit variant of the current architecture.
Definition: Triple.cpp:1561
llvm::Triple::isLittleEndian
bool isLittleEndian() const
Tests whether the target triple is little endian.
Definition: Triple.cpp:1745
llvm::Triple::setEnvironment
void setEnvironment(EnvironmentType Kind)
Set the environment (fourth) component of the triple to a known type.
Definition: Triple.cpp:1347
llvm::Triple::getOSName
StringRef getOSName() const
Get the operating system (third) component of the triple.
Definition: Triple.cpp:1184
llvm::Triple::loongarch32
@ loongarch32
Definition: Triple.h:61
llvm::Triple::renderscript64
@ renderscript64
Definition: Triple.h:107
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:106
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:1331
llvm::Triple::getOS
OSType getOS() const
Get the parsed operating system type of this triple.
Definition: Triple.h:364
llvm::Triple::getEnvironmentVersion
VersionTuple getEnvironmentVersion() const
Parse the version number from the OS name component of the triple, if present.
Definition: Triple.cpp:1207
llvm::Triple::getArchTypeForLLVMName
static ArchType getArchTypeForLLVMName(StringRef Str)
The canonical type for the given LLVM architecture name (e.g., "x86").
Definition: Triple.cpp:313
llvm::Triple::getArch
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:355
llvm::Triple::getEnvironmentName
StringRef getEnvironmentName() const
Get the optional environment (fourth) component of the triple, or "" if empty.
Definition: Triple.cpp:1190
llvm::Triple::isSimulatorEnvironment
bool isSimulatorEnvironment() const
Definition: Triple.h:522
llvm::Triple::str
const std::string & str() const
Definition: Triple.h:414
llvm::Triple::getEnvironment
EnvironmentType getEnvironment() const
Get the parsed environment type of this triple.
Definition: Triple.h:372
llvm::Triple::getDriverKitVersion
VersionTuple getDriverKitVersion() const
Parse the version number as with getOSVersion.
Definition: Triple.cpp:1319
llvm::Triple::getArchTypeName
static StringRef getArchTypeName(ArchType Kind)
Get the canonical name for the Kind architecture.
Definition: Triple.cpp:23
llvm::Triple::getOSTypeName
static StringRef getOSTypeName(OSType Kind)
Get the canonical name for the Kind operating system.
Definition: Triple.cpp:204
llvm::Triple::ObjectFormatType
ObjectFormatType
Definition: Triple.h:279
llvm::Triple::DXContainer
@ DXContainer
Definition: Triple.h:283
llvm::Triple::UnknownObjectFormat
@ UnknownObjectFormat
Definition: Triple.h:280
llvm::Triple::merge
std::string merge(const Triple &Other) const
Merge target triples.
Definition: Triple.cpp:1822
llvm::Triple::UnknownVendor
@ UnknownVendor
Definition: Triple.h:167
llvm::Triple::OpenEmbedded
@ OpenEmbedded
Definition: Triple.h:182
llvm::Triple::ImaginationTechnologies
@ ImaginationTechnologies
Definition: Triple.h:174
llvm::Triple::MipsTechnologies
@ MipsTechnologies
Definition: Triple.h:175
llvm::Triple::getMinimumSupportedOSVersion
VersionTuple getMinimumSupportedOSVersion() const
Some platforms have different minimum supported OS versions that varies by the architecture specified...
Definition: Triple.cpp:1848
llvm::Triple::isArch64Bit
bool isArch64Bit() const
Test whether the architecture is 64-bit.
Definition: Triple.cpp:1469
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:1196
llvm::Triple::ARMSubArch_v6t2
@ ARMSubArch_v6t2
Definition: Triple.h:142
llvm::Triple::MipsSubArch_r6
@ MipsSubArch_r6
Definition: Triple.h:154
llvm::Triple::ARMSubArch_v7
@ ARMSubArch_v7
Definition: Triple.h:133
llvm::Triple::ARMSubArch_v8m_mainline
@ ARMSubArch_v8m_mainline
Definition: Triple.h:131
llvm::Triple::ARMSubArch_v8r
@ ARMSubArch_v8r
Definition: Triple.h:129
llvm::Triple::ARMSubArch_v9_1a
@ ARMSubArch_v9_1a
Definition: Triple.h:117
llvm::Triple::SPIRVSubArch_v10
@ SPIRVSubArch_v10
Definition: Triple.h:159
llvm::Triple::SPIRVSubArch_v13
@ SPIRVSubArch_v13
Definition: Triple.h:162
llvm::Triple::ARMSubArch_v7k
@ ARMSubArch_v7k
Definition: Triple.h:137
llvm::Triple::ARMSubArch_v8_7a
@ ARMSubArch_v8_7a
Definition: Triple.h:121
llvm::Triple::ARMSubArch_v8
@ ARMSubArch_v8
Definition: Triple.h:128
llvm::Triple::ARMSubArch_v8_1a
@ ARMSubArch_v8_1a
Definition: Triple.h:127
llvm::Triple::ARMSubArch_v9_2a
@ ARMSubArch_v9_2a
Definition: Triple.h:116
llvm::Triple::SPIRVSubArch_v15
@ SPIRVSubArch_v15
Definition: Triple.h:164
llvm::Triple::ARMSubArch_v7m
@ ARMSubArch_v7m
Definition: Triple.h:135
llvm::Triple::ARMSubArch_v6k
@ ARMSubArch_v6k
Definition: Triple.h:141
llvm::Triple::ARMSubArch_v5
@ ARMSubArch_v5
Definition: Triple.h:143
llvm::Triple::AArch64SubArch_arm64e
@ AArch64SubArch_arm64e
Definition: Triple.h:147
llvm::Triple::ARMSubArch_v6
@ ARMSubArch_v6
Definition: Triple.h:139
llvm::Triple::ARMSubArch_v7ve
@ ARMSubArch_v7ve
Definition: Triple.h:138
llvm::Triple::ARMSubArch_v8m_baseline
@ ARMSubArch_v8m_baseline
Definition: Triple.h:130
llvm::Triple::ARMSubArch_v8_8a
@ ARMSubArch_v8_8a
Definition: Triple.h:120
llvm::Triple::ARMSubArch_v8_2a
@ ARMSubArch_v8_2a
Definition: Triple.h:126
llvm::Triple::ARMSubArch_v7s
@ ARMSubArch_v7s
Definition: Triple.h:136
llvm::Triple::KalimbaSubArch_v3
@ KalimbaSubArch_v3
Definition: Triple.h:150
llvm::Triple::ARMSubArch_v8_4a
@ ARMSubArch_v8_4a
Definition: Triple.h:124
llvm::Triple::ARMSubArch_v8_9a
@ ARMSubArch_v8_9a
Definition: Triple.h:119
llvm::Triple::ARMSubArch_v7em
@ ARMSubArch_v7em
Definition: Triple.h:134
llvm::Triple::SPIRVSubArch_v12
@ SPIRVSubArch_v12
Definition: Triple.h:161
llvm::Triple::SPIRVSubArch_v14
@ SPIRVSubArch_v14
Definition: Triple.h:163
llvm::Triple::KalimbaSubArch_v4
@ KalimbaSubArch_v4
Definition: Triple.h:151
llvm::Triple::ARMSubArch_v8_1m_mainline
@ ARMSubArch_v8_1m_mainline
Definition: Triple.h:132
llvm::Triple::ARMSubArch_v8_3a
@ ARMSubArch_v8_3a
Definition: Triple.h:125
llvm::Triple::AArch64SubArch_arm64ec
@ AArch64SubArch_arm64ec
Definition: Triple.h:148
llvm::Triple::ARMSubArch_v8_6a
@ ARMSubArch_v8_6a
Definition: Triple.h:122
llvm::Triple::ARMSubArch_v5te
@ ARMSubArch_v5te
Definition: Triple.h:144
llvm::Triple::KalimbaSubArch_v5
@ KalimbaSubArch_v5
Definition: Triple.h:152
llvm::Triple::ARMSubArch_v4t
@ ARMSubArch_v4t
Definition: Triple.h:145
llvm::Triple::ARMSubArch_v9_4a
@ ARMSubArch_v9_4a
Definition: Triple.h:114
llvm::Triple::ARMSubArch_v8_5a
@ ARMSubArch_v8_5a
Definition: Triple.h:123
llvm::Triple::ARMSubArch_v6m
@ ARMSubArch_v6m
Definition: Triple.h:140
llvm::Triple::ARMSubArch_v9_3a
@ ARMSubArch_v9_3a
Definition: Triple.h:115
llvm::Triple::ARMSubArch_v9
@ ARMSubArch_v9
Definition: Triple.h:118
llvm::Triple::SPIRVSubArch_v11
@ SPIRVSubArch_v11
Definition: Triple.h:160
llvm::Triple::PPCSubArch_spe
@ PPCSubArch_spe
Definition: Triple.h:156
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:1228
llvm::Triple::isMacOSX
bool isMacOSX() const
Is this a Mac OS X triple.
Definition: Triple.h:485
llvm::Triple::setEnvironmentName
void setEnvironmentName(StringRef Str)
Set the optional environment (fourth) component of the triple by name.
Definition: Triple.cpp:1386
llvm::Triple::setOS
void setOS(OSType Kind)
Set the operating system (third) component of the triple to a known type.
Definition: Triple.cpp:1343
llvm::Triple::setOSName
void setOSName(StringRef Str)
Set the operating system (third) component of the triple by name.
Definition: Triple.cpp:1378
llvm::Triple::getVendor
VendorType getVendor() const
Get the parsed vendor type of this triple.
Definition: Triple.h:361
llvm::Triple::getEnvironmentTypeName
static StringRef getEnvironmentTypeName(EnvironmentType Kind)
Get the canonical name for the Kind environment.
Definition: Triple.cpp:251
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:463
llvm::Triple::getCanonicalVersionForOS
static VersionTuple getCanonicalVersionForOS(OSType OSKind, const VersionTuple &Version)
Returns a canonicalized OS version number for the specified OS.
Definition: Triple.cpp:1882
llvm::Triple::getArchName
StringRef getArchName() const
Get the architecture (first) component of the triple.
Definition: Triple.cpp:1147
llvm::Triple::isMacCatalystEnvironment
bool isMacCatalystEnvironment() const
Definition: Triple.h:526
llvm::Triple::isArch16Bit
bool isArch16Bit() const
Test whether the architecture is 16-bit.
Definition: Triple.cpp:1477
llvm::Triple::getBigEndianArchVariant
llvm::Triple getBigEndianArchVariant() const
Form a triple with a big endian variant of the current architecture.
Definition: Triple.cpp:1641
llvm::Triple::getiOSVersion
VersionTuple getiOSVersion() const
Parse the version number as with getOSVersion.
Definition: Triple.cpp:1271
llvm::Triple::isArch32Bit
bool isArch32Bit() const
Test whether the architecture is 32-bit.
Definition: Triple.cpp:1473
llvm::Triple::isCompatibleWith
bool isCompatibleWith(const Triple &Other) const
Test whether target triples are compatible.
Definition: Triple.cpp:1798
llvm::Triple::hasEnvironment
bool hasEnvironment() const
Does this triple have the optional environment (fourth) component?
Definition: Triple.h:367
llvm::Triple::getArchTypePrefix
static StringRef getArchTypePrefix(ArchType Kind)
Get the "prefix" canonical name for the Kind architecture.
Definition: Triple.cpp:92
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:1335
llvm::Triple::setVendor
void setVendor(VendorType Kind)
Set the vendor (second) component of the triple to a known type.
Definition: Triple.cpp:1339
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:31
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:53
llvm::ARM::parseArchISA
ISAKind parseArchISA(StringRef Arch)
Definition: ARMTargetParserCommon.cpp:108
llvm::ARM::parseArch
ArchKind parseArch(StringRef Arch)
Definition: ARMTargetParser.cpp:29
llvm::ARM::parseArchProfile
ProfileKind parseArchProfile(StringRef Arch)
Definition: ARMTargetParser.cpp:145
llvm::ARM::parseArchVersion
unsigned parseArchVersion(StringRef Arch)
Definition: ARMTargetParser.cpp:40
llvm::ARM::parseArchEndian
EndianKind parseArchEndian(StringRef Arch)
Definition: ARMTargetParserCommon.cpp:117
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:67
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::swap
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:853
Generated on Fri Feb 3 2023 10:55:48 for LLVM by doxygen 1.9.6