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>
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   case xtensa:         return "xtensa";
87   }
88 
89   llvm_unreachable("Invalid ArchType!");
90 }
91 
getArchTypePrefix(ArchType Kind)92 StringRef 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 
getVendorTypeName(VendorType Kind)181 StringRef 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 
getOSTypeName(OSType Kind)204 StringRef 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 
getEnvironmentTypeName(EnvironmentType Kind)251 StringRef 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 
parseBPFArch(StringRef ArchName)298 static 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 
getArchTypeForLLVMName(StringRef Name)313 Triple::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 
parseARMArch(StringRef ArchName)384 static 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 
parseArch(StringRef ArchName)449 static 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 
parseVendor(StringRef VendorName)538 static 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 
parseOS(StringRef OSName)558 static 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 
parseEnvironment(StringRef EnvironmentName)602 static 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 
parseFormat(StringRef EnvironmentName)646 static 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 
parseSubArch(StringRef SubArchName)660 static 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 
getObjectFormatTypeName(Triple::ObjectFormatType Kind)773 static 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 
getDefaultFormat(const Triple & T)797 static 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.
Triple(const Twine & Str)889 Triple::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.
Triple(const Twine & ArchStr,const Twine & VendorStr,const Twine & OSStr)929 Triple::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.
Triple(const Twine & ArchStr,const Twine & VendorStr,const Twine & OSStr,const Twine & EnvironmentStr)944 Triple::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 
normalize(StringRef Str)958 std::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 
getArchName() const1147 StringRef Triple::getArchName() const {
1148   return StringRef(Data).split('-').first;           // Isolate first component
1149 }
1150 
getArchName(ArchType Kind,SubArchType SubArch) const1151 StringRef 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 
getVendorName() const1179 StringRef Triple::getVendorName() const {
1180   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
1181   return Tmp.split('-').first;                       // Isolate second component
1182 }
1183 
getOSName() const1184 StringRef 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 
getEnvironmentName() const1190 StringRef 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 
getOSAndEnvironmentName() const1196 StringRef Triple::getOSAndEnvironmentName() const {
1197   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
1198   return Tmp.split('-').second;                      // Strip second component
1199 }
1200 
parseVersionFromName(StringRef Name)1201 static VersionTuple parseVersionFromName(StringRef Name) {
1202   VersionTuple Version;
1203   Version.tryParse(Name);
1204   return Version.withoutBuild();
1205 }
1206 
getEnvironmentVersion() const1207 VersionTuple 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 
getOSVersion() const1216 VersionTuple 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 
getMacOSXVersion(VersionTuple & Version) const1228 bool 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 
getiOSVersion() const1271 VersionTuple 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 
getWatchOSVersion() const1296 VersionTuple 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 
getDriverKitVersion() const1319 VersionTuple 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 
setTriple(const Twine & Str)1331 void Triple::setTriple(const Twine &Str) {
1332   *this = Triple(Str);
1333 }
1334 
setArch(ArchType Kind,SubArchType SubArch)1335 void Triple::setArch(ArchType Kind, SubArchType SubArch) {
1336   setArchName(getArchName(Kind, SubArch));
1337 }
1338 
setVendor(VendorType Kind)1339 void Triple::setVendor(VendorType Kind) {
1340   setVendorName(getVendorTypeName(Kind));
1341 }
1342 
setOS(OSType Kind)1343 void Triple::setOS(OSType Kind) {
1344   setOSName(getOSTypeName(Kind));
1345 }
1346 
setEnvironment(EnvironmentType Kind)1347 void 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 
setObjectFormat(ObjectFormatType Kind)1355 void 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 
setArchName(StringRef Str)1363 void 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 
setVendorName(StringRef Str)1374 void Triple::setVendorName(StringRef Str) {
1375   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1376 }
1377 
setOSName(StringRef Str)1378 void Triple::setOSName(StringRef Str) {
1379   if (hasEnvironment())
1380     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1381               "-" + getEnvironmentName());
1382   else
1383     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1384 }
1385 
setEnvironmentName(StringRef Str)1386 void Triple::setEnvironmentName(StringRef Str) {
1387   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1388             "-" + Str);
1389 }
1390 
setOSAndEnvironmentName(StringRef Str)1391 void Triple::setOSAndEnvironmentName(StringRef Str) {
1392   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1393 }
1394 
getArchPointerBitWidth(llvm::Triple::ArchType Arch)1395 static 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 
isArch64Bit() const1469 bool Triple::isArch64Bit() const {
1470   return getArchPointerBitWidth(getArch()) == 64;
1471 }
1472 
isArch32Bit() const1473 bool Triple::isArch32Bit() const {
1474   return getArchPointerBitWidth(getArch()) == 32;
1475 }
1476 
isArch16Bit() const1477 bool Triple::isArch16Bit() const {
1478   return getArchPointerBitWidth(getArch()) == 16;
1479 }
1480 
get32BitArchVariant() const1481 Triple 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 
get64BitArchVariant() const1561 Triple 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 
getBigEndianArchVariant() const1641 Triple 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 
getLittleEndianArchVariant() const1708 Triple 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 
isLittleEndian() const1745 bool 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 
isCompatibleWith(const Triple & Other) const1798 bool 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 
merge(const Triple & Other) const1822 std::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 
isMacOSXVersionLT(unsigned Major,unsigned Minor,unsigned Micro) const1831 bool 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 
getMinimumSupportedOSVersion() const1848 VersionTuple 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 
getCanonicalVersionForOS(OSType OSKind,const VersionTuple & Version)1882 VersionTuple 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
1896 static_assert(Triple::Vertex - Triple::Pixel == 1,
1897               "incorrect HLSL stage order");
1898 static_assert(Triple::Geometry - Triple::Pixel == 2,
1899               "incorrect HLSL stage order");
1900 static_assert(Triple::Hull - Triple::Pixel == 3,
1901               "incorrect HLSL stage order");
1902 static_assert(Triple::Domain - Triple::Pixel == 4,
1903               "incorrect HLSL stage order");
1904 static_assert(Triple::Compute - Triple::Pixel == 5,
1905               "incorrect HLSL stage order");
1906 static_assert(Triple::Library - Triple::Pixel == 6,
1907               "incorrect HLSL stage order");
1908 static_assert(Triple::RayGeneration - Triple::Pixel == 7,
1909               "incorrect HLSL stage order");
1910 static_assert(Triple::Intersection - Triple::Pixel == 8,
1911               "incorrect HLSL stage order");
1912 static_assert(Triple::AnyHit - Triple::Pixel == 9,
1913               "incorrect HLSL stage order");
1914 static_assert(Triple::ClosestHit - Triple::Pixel == 10,
1915               "incorrect HLSL stage order");
1916 static_assert(Triple::Miss - Triple::Pixel == 11,
1917               "incorrect HLSL stage order");
1918 static_assert(Triple::Callable - Triple::Pixel == 12,
1919               "incorrect HLSL stage order");
1920 static_assert(Triple::Mesh - Triple::Pixel == 13,
1921               "incorrect HLSL stage order");
1922 static_assert(Triple::Amplification - Triple::Pixel == 14,
1923               "incorrect HLSL stage order");
1924