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