LLVM  6.0.0svn
Triple.cpp
Go to the documentation of this file.
1 //===--- Triple.cpp - Target triple helper class --------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/ADT/Triple.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringSwitch.h"
15 #include "llvm/Support/Host.h"
17 #include <cstring>
18 using namespace llvm;
19 
21  switch (Kind) {
22  case UnknownArch: return "unknown";
23 
24  case aarch64: return "aarch64";
25  case aarch64_be: return "aarch64_be";
26  case arm: return "arm";
27  case armeb: return "armeb";
28  case arc: return "arc";
29  case avr: return "avr";
30  case bpfel: return "bpfel";
31  case bpfeb: return "bpfeb";
32  case hexagon: return "hexagon";
33  case mips: return "mips";
34  case mipsel: return "mipsel";
35  case mips64: return "mips64";
36  case mips64el: return "mips64el";
37  case msp430: return "msp430";
38  case nios2: return "nios2";
39  case ppc64: return "powerpc64";
40  case ppc64le: return "powerpc64le";
41  case ppc: return "powerpc";
42  case r600: return "r600";
43  case amdgcn: return "amdgcn";
44  case riscv32: return "riscv32";
45  case riscv64: return "riscv64";
46  case sparc: return "sparc";
47  case sparcv9: return "sparcv9";
48  case sparcel: return "sparcel";
49  case systemz: return "s390x";
50  case tce: return "tce";
51  case tcele: return "tcele";
52  case thumb: return "thumb";
53  case thumbeb: return "thumbeb";
54  case x86: return "i386";
55  case x86_64: return "x86_64";
56  case xcore: return "xcore";
57  case nvptx: return "nvptx";
58  case nvptx64: return "nvptx64";
59  case le32: return "le32";
60  case le64: return "le64";
61  case amdil: return "amdil";
62  case amdil64: return "amdil64";
63  case hsail: return "hsail";
64  case hsail64: return "hsail64";
65  case spir: return "spir";
66  case spir64: return "spir64";
67  case kalimba: return "kalimba";
68  case lanai: return "lanai";
69  case shave: return "shave";
70  case wasm32: return "wasm32";
71  case wasm64: return "wasm64";
72  case renderscript32: return "renderscript32";
73  case renderscript64: return "renderscript64";
74  }
75 
76  llvm_unreachable("Invalid ArchType!");
77 }
78 
80  switch (Kind) {
81  default:
82  return StringRef();
83 
84  case aarch64:
85  case aarch64_be: return "aarch64";
86 
87  case arc: return "arc";
88 
89  case arm:
90  case armeb:
91  case thumb:
92  case thumbeb: return "arm";
93 
94  case avr: return "avr";
95 
96  case ppc64:
97  case ppc64le:
98  case ppc: return "ppc";
99 
100  case mips:
101  case mipsel:
102  case mips64:
103  case mips64el: return "mips";
104 
105  case nios2: return "nios2";
106 
107  case hexagon: return "hexagon";
108 
109  case amdgcn: return "amdgcn";
110  case r600: return "r600";
111 
112  case bpfel:
113  case bpfeb: return "bpf";
114 
115  case sparcv9:
116  case sparcel:
117  case sparc: return "sparc";
118 
119  case systemz: return "s390";
120 
121  case x86:
122  case x86_64: return "x86";
123 
124  case xcore: return "xcore";
125 
126  // NVPTX intrinsics are namespaced under nvvm.
127  case nvptx: return "nvvm";
128  case nvptx64: return "nvvm";
129 
130  case le32: return "le32";
131  case le64: return "le64";
132 
133  case amdil:
134  case amdil64: return "amdil";
135 
136  case hsail:
137  case hsail64: return "hsail";
138 
139  case spir:
140  case spir64: return "spir";
141  case kalimba: return "kalimba";
142  case lanai: return "lanai";
143  case shave: return "shave";
144  case wasm32:
145  case wasm64: return "wasm";
146 
147  case riscv32:
148  case riscv64: return "riscv";
149  }
150 }
151 
153  switch (Kind) {
154  case UnknownVendor: return "unknown";
155 
156  case Apple: return "apple";
157  case PC: return "pc";
158  case SCEI: return "scei";
159  case BGP: return "bgp";
160  case BGQ: return "bgq";
161  case Freescale: return "fsl";
162  case IBM: return "ibm";
163  case ImaginationTechnologies: return "img";
164  case MipsTechnologies: return "mti";
165  case NVIDIA: return "nvidia";
166  case CSR: return "csr";
167  case Myriad: return "myriad";
168  case AMD: return "amd";
169  case Mesa: return "mesa";
170  case SUSE: return "suse";
171  }
172 
173  llvm_unreachable("Invalid VendorType!");
174 }
175 
177  switch (Kind) {
178  case UnknownOS: return "unknown";
179 
180  case Ananas: return "ananas";
181  case CloudABI: return "cloudabi";
182  case Darwin: return "darwin";
183  case DragonFly: return "dragonfly";
184  case FreeBSD: return "freebsd";
185  case Fuchsia: return "fuchsia";
186  case IOS: return "ios";
187  case KFreeBSD: return "kfreebsd";
188  case Linux: return "linux";
189  case Lv2: return "lv2";
190  case MacOSX: return "macosx";
191  case NetBSD: return "netbsd";
192  case OpenBSD: return "openbsd";
193  case Solaris: return "solaris";
194  case Win32: return "windows";
195  case Haiku: return "haiku";
196  case Minix: return "minix";
197  case RTEMS: return "rtems";
198  case NaCl: return "nacl";
199  case CNK: return "cnk";
200  case AIX: return "aix";
201  case CUDA: return "cuda";
202  case NVCL: return "nvcl";
203  case AMDHSA: return "amdhsa";
204  case PS4: return "ps4";
205  case ELFIAMCU: return "elfiamcu";
206  case TvOS: return "tvos";
207  case WatchOS: return "watchos";
208  case Mesa3D: return "mesa3d";
209  case Contiki: return "contiki";
210  case AMDPAL: return "amdpal";
211  }
212 
213  llvm_unreachable("Invalid OSType");
214 }
215 
217  switch (Kind) {
218  case UnknownEnvironment: return "unknown";
219  case GNU: return "gnu";
220  case GNUABIN32: return "gnuabin32";
221  case GNUABI64: return "gnuabi64";
222  case GNUEABIHF: return "gnueabihf";
223  case GNUEABI: return "gnueabi";
224  case GNUX32: return "gnux32";
225  case CODE16: return "code16";
226  case EABI: return "eabi";
227  case EABIHF: return "eabihf";
228  case Android: return "android";
229  case Musl: return "musl";
230  case MuslEABI: return "musleabi";
231  case MuslEABIHF: return "musleabihf";
232  case MSVC: return "msvc";
233  case Itanium: return "itanium";
234  case Cygnus: return "cygnus";
235  case AMDOpenCL: return "amdopencl";
236  case CoreCLR: return "coreclr";
237  case OpenCL: return "opencl";
238  case Simulator: return "simulator";
239  }
240 
241  llvm_unreachable("Invalid EnvironmentType!");
242 }
243 
245  if (ArchName.equals("bpf")) {
247  return Triple::bpfel;
248  else
249  return Triple::bpfeb;
250  } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
251  return Triple::bpfeb;
252  } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
253  return Triple::bpfel;
254  } else {
255  return Triple::UnknownArch;
256  }
257 }
258 
260  Triple::ArchType BPFArch(parseBPFArch(Name));
262  .Case("aarch64", aarch64)
263  .Case("aarch64_be", aarch64_be)
264  .Case("arc", arc)
265  .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
266  .Case("arm", arm)
267  .Case("armeb", armeb)
268  .Case("avr", avr)
269  .StartsWith("bpf", BPFArch)
270  .Case("mips", mips)
271  .Case("mipsel", mipsel)
272  .Case("mips64", mips64)
273  .Case("mips64el", mips64el)
274  .Case("msp430", msp430)
275  .Case("nios2", nios2)
276  .Case("ppc64", ppc64)
277  .Case("ppc32", ppc)
278  .Case("ppc", ppc)
279  .Case("ppc64le", ppc64le)
280  .Case("r600", r600)
281  .Case("amdgcn", amdgcn)
282  .Case("riscv32", riscv32)
283  .Case("riscv64", riscv64)
284  .Case("hexagon", hexagon)
285  .Case("sparc", sparc)
286  .Case("sparcel", sparcel)
287  .Case("sparcv9", sparcv9)
288  .Case("systemz", systemz)
289  .Case("tce", tce)
290  .Case("tcele", tcele)
291  .Case("thumb", thumb)
292  .Case("thumbeb", thumbeb)
293  .Case("x86", x86)
294  .Case("x86-64", x86_64)
295  .Case("xcore", xcore)
296  .Case("nvptx", nvptx)
297  .Case("nvptx64", nvptx64)
298  .Case("le32", le32)
299  .Case("le64", le64)
300  .Case("amdil", amdil)
301  .Case("amdil64", amdil64)
302  .Case("hsail", hsail)
303  .Case("hsail64", hsail64)
304  .Case("spir", spir)
305  .Case("spir64", spir64)
306  .Case("kalimba", kalimba)
307  .Case("lanai", lanai)
308  .Case("shave", shave)
309  .Case("wasm32", wasm32)
310  .Case("wasm64", wasm64)
311  .Case("renderscript32", renderscript32)
312  .Case("renderscript64", renderscript64)
314 }
315 
317  ARM::ISAKind ISA = ARM::parseArchISA(ArchName);
318  ARM::EndianKind ENDIAN = ARM::parseArchEndian(ArchName);
319 
321  switch (ENDIAN) {
323  switch (ISA) {
324  case ARM::ISAKind::ARM:
325  arch = Triple::arm;
326  break;
327  case ARM::ISAKind::THUMB:
328  arch = Triple::thumb;
329  break;
331  arch = Triple::aarch64;
332  break;
334  break;
335  }
336  break;
337  }
338  case ARM::EndianKind::BIG: {
339  switch (ISA) {
340  case ARM::ISAKind::ARM:
341  arch = Triple::armeb;
342  break;
343  case ARM::ISAKind::THUMB:
344  arch = Triple::thumbeb;
345  break;
347  arch = Triple::aarch64_be;
348  break;
350  break;
351  }
352  break;
353  }
355  break;
356  }
357  }
358 
359  ArchName = ARM::getCanonicalArchName(ArchName);
360  if (ArchName.empty())
361  return Triple::UnknownArch;
362 
363  // Thumb only exists in v4+
364  if (ISA == ARM::ISAKind::THUMB &&
365  (ArchName.startswith("v2") || ArchName.startswith("v3")))
366  return Triple::UnknownArch;
367 
368  // Thumb only for v6m
369  ARM::ProfileKind Profile = ARM::parseArchProfile(ArchName);
370  unsigned Version = ARM::parseArchVersion(ArchName);
371  if (Profile == ARM::ProfileKind::M && Version == 6) {
372  if (ENDIAN == ARM::EndianKind::BIG)
373  return Triple::thumbeb;
374  else
375  return Triple::thumb;
376  }
377 
378  return arch;
379 }
380 
382  auto AT = StringSwitch<Triple::ArchType>(ArchName)
383  .Cases("i386", "i486", "i586", "i686", Triple::x86)
384  // FIXME: Do we need to support these?
385  .Cases("i786", "i886", "i986", Triple::x86)
386  .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
387  .Cases("powerpc", "ppc32", Triple::ppc)
388  .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)
389  .Cases("powerpc64le", "ppc64le", Triple::ppc64le)
390  .Case("xscale", Triple::arm)
391  .Case("xscaleeb", Triple::armeb)
392  .Case("aarch64", Triple::aarch64)
393  .Case("aarch64_be", Triple::aarch64_be)
394  .Case("arc", Triple::arc)
395  .Case("arm64", Triple::aarch64)
396  .Case("arm", Triple::arm)
397  .Case("armeb", Triple::armeb)
398  .Case("thumb", Triple::thumb)
399  .Case("thumbeb", Triple::thumbeb)
400  .Case("avr", Triple::avr)
401  .Case("msp430", Triple::msp430)
402  .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
403  .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
404  .Cases("mips64", "mips64eb", Triple::mips64)
405  .Case("mips64el", Triple::mips64el)
406  .Case("nios2", Triple::nios2)
407  .Case("r600", Triple::r600)
408  .Case("amdgcn", Triple::amdgcn)
409  .Case("riscv32", Triple::riscv32)
410  .Case("riscv64", Triple::riscv64)
411  .Case("hexagon", Triple::hexagon)
412  .Cases("s390x", "systemz", Triple::systemz)
413  .Case("sparc", Triple::sparc)
414  .Case("sparcel", Triple::sparcel)
415  .Cases("sparcv9", "sparc64", Triple::sparcv9)
416  .Case("tce", Triple::tce)
417  .Case("tcele", Triple::tcele)
418  .Case("xcore", Triple::xcore)
419  .Case("nvptx", Triple::nvptx)
420  .Case("nvptx64", Triple::nvptx64)
421  .Case("le32", Triple::le32)
422  .Case("le64", Triple::le64)
423  .Case("amdil", Triple::amdil)
424  .Case("amdil64", Triple::amdil64)
425  .Case("hsail", Triple::hsail)
426  .Case("hsail64", Triple::hsail64)
427  .Case("spir", Triple::spir)
428  .Case("spir64", Triple::spir64)
429  .StartsWith("kalimba", Triple::kalimba)
430  .Case("lanai", Triple::lanai)
431  .Case("shave", Triple::shave)
432  .Case("wasm32", Triple::wasm32)
433  .Case("wasm64", Triple::wasm64)
434  .Case("renderscript32", Triple::renderscript32)
435  .Case("renderscript64", Triple::renderscript64)
437 
438  // Some architectures require special parsing logic just to compute the
439  // ArchType result.
440  if (AT == Triple::UnknownArch) {
441  if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
442  ArchName.startswith("aarch64"))
443  return parseARMArch(ArchName);
444  if (ArchName.startswith("bpf"))
445  return parseBPFArch(ArchName);
446  }
447 
448  return AT;
449 }
450 
452  return StringSwitch<Triple::VendorType>(VendorName)
453  .Case("apple", Triple::Apple)
454  .Case("pc", Triple::PC)
455  .Case("scei", Triple::SCEI)
456  .Case("bgp", Triple::BGP)
457  .Case("bgq", Triple::BGQ)
458  .Case("fsl", Triple::Freescale)
459  .Case("ibm", Triple::IBM)
462  .Case("nvidia", Triple::NVIDIA)
463  .Case("csr", Triple::CSR)
464  .Case("myriad", Triple::Myriad)
465  .Case("amd", Triple::AMD)
466  .Case("mesa", Triple::Mesa)
467  .Case("suse", Triple::SUSE)
469 }
470 
472  return StringSwitch<Triple::OSType>(OSName)
473  .StartsWith("ananas", Triple::Ananas)
474  .StartsWith("cloudabi", Triple::CloudABI)
475  .StartsWith("darwin", Triple::Darwin)
476  .StartsWith("dragonfly", Triple::DragonFly)
477  .StartsWith("freebsd", Triple::FreeBSD)
478  .StartsWith("fuchsia", Triple::Fuchsia)
479  .StartsWith("ios", Triple::IOS)
480  .StartsWith("kfreebsd", Triple::KFreeBSD)
481  .StartsWith("linux", Triple::Linux)
482  .StartsWith("lv2", Triple::Lv2)
483  .StartsWith("macos", Triple::MacOSX)
484  .StartsWith("netbsd", Triple::NetBSD)
485  .StartsWith("openbsd", Triple::OpenBSD)
486  .StartsWith("solaris", Triple::Solaris)
487  .StartsWith("win32", Triple::Win32)
488  .StartsWith("windows", Triple::Win32)
489  .StartsWith("haiku", Triple::Haiku)
490  .StartsWith("minix", Triple::Minix)
491  .StartsWith("rtems", Triple::RTEMS)
492  .StartsWith("nacl", Triple::NaCl)
493  .StartsWith("cnk", Triple::CNK)
494  .StartsWith("aix", Triple::AIX)
495  .StartsWith("cuda", Triple::CUDA)
496  .StartsWith("nvcl", Triple::NVCL)
497  .StartsWith("amdhsa", Triple::AMDHSA)
498  .StartsWith("ps4", Triple::PS4)
499  .StartsWith("elfiamcu", Triple::ELFIAMCU)
500  .StartsWith("tvos", Triple::TvOS)
501  .StartsWith("watchos", Triple::WatchOS)
502  .StartsWith("mesa3d", Triple::Mesa3D)
503  .StartsWith("contiki", Triple::Contiki)
504  .StartsWith("amdpal", Triple::AMDPAL)
506 }
507 
509  return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
510  .StartsWith("eabihf", Triple::EABIHF)
511  .StartsWith("eabi", Triple::EABI)
512  .StartsWith("gnuabin32", Triple::GNUABIN32)
513  .StartsWith("gnuabi64", Triple::GNUABI64)
514  .StartsWith("gnueabihf", Triple::GNUEABIHF)
515  .StartsWith("gnueabi", Triple::GNUEABI)
516  .StartsWith("gnux32", Triple::GNUX32)
517  .StartsWith("code16", Triple::CODE16)
518  .StartsWith("gnu", Triple::GNU)
519  .StartsWith("android", Triple::Android)
520  .StartsWith("musleabihf", Triple::MuslEABIHF)
521  .StartsWith("musleabi", Triple::MuslEABI)
522  .StartsWith("musl", Triple::Musl)
523  .StartsWith("msvc", Triple::MSVC)
524  .StartsWith("itanium", Triple::Itanium)
525  .StartsWith("cygnus", Triple::Cygnus)
526  .StartsWith("amdopencl", Triple::AMDOpenCL)
527  .StartsWith("coreclr", Triple::CoreCLR)
528  .StartsWith("opencl", Triple::OpenCL)
529  .StartsWith("simulator", Triple::Simulator)
531 }
532 
534  return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
535  .EndsWith("coff", Triple::COFF)
536  .EndsWith("elf", Triple::ELF)
537  .EndsWith("macho", Triple::MachO)
538  .EndsWith("wasm", Triple::Wasm)
540 }
541 
543  StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
544 
545  // For now, this is the small part. Early return.
546  if (ARMSubArch.empty())
547  return StringSwitch<Triple::SubArchType>(SubArchName)
548  .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
549  .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
550  .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
552 
553  // ARM sub arch.
554  switch(ARM::parseArch(ARMSubArch)) {
555  case ARM::ArchKind::ARMV4:
556  return Triple::NoSubArch;
557  case ARM::ArchKind::ARMV4T:
558  return Triple::ARMSubArch_v4t;
559  case ARM::ArchKind::ARMV5T:
560  return Triple::ARMSubArch_v5;
561  case ARM::ArchKind::ARMV5TE:
562  case ARM::ArchKind::IWMMXT:
563  case ARM::ArchKind::IWMMXT2:
564  case ARM::ArchKind::XSCALE:
565  case ARM::ArchKind::ARMV5TEJ:
567  case ARM::ArchKind::ARMV6:
568  return Triple::ARMSubArch_v6;
569  case ARM::ArchKind::ARMV6K:
570  case ARM::ArchKind::ARMV6KZ:
571  return Triple::ARMSubArch_v6k;
572  case ARM::ArchKind::ARMV6T2:
574  case ARM::ArchKind::ARMV6M:
575  return Triple::ARMSubArch_v6m;
576  case ARM::ArchKind::ARMV7A:
577  case ARM::ArchKind::ARMV7R:
578  return Triple::ARMSubArch_v7;
579  case ARM::ArchKind::ARMV7VE:
581  case ARM::ArchKind::ARMV7K:
582  return Triple::ARMSubArch_v7k;
583  case ARM::ArchKind::ARMV7M:
584  return Triple::ARMSubArch_v7m;
585  case ARM::ArchKind::ARMV7S:
586  return Triple::ARMSubArch_v7s;
587  case ARM::ArchKind::ARMV7EM:
589  case ARM::ArchKind::ARMV8A:
590  return Triple::ARMSubArch_v8;
591  case ARM::ArchKind::ARMV8_1A:
593  case ARM::ArchKind::ARMV8_2A:
595  case ARM::ArchKind::ARMV8_3A:
597  case ARM::ArchKind::ARMV8R:
598  return Triple::ARMSubArch_v8r;
599  case ARM::ArchKind::ARMV8MBaseline:
601  case ARM::ArchKind::ARMV8MMainline:
603  default:
604  return Triple::NoSubArch;
605  }
606 }
607 
609  switch (Kind) {
610  case Triple::UnknownObjectFormat: return "";
611  case Triple::COFF: return "coff";
612  case Triple::ELF: return "elf";
613  case Triple::MachO: return "macho";
614  case Triple::Wasm: return "wasm";
615  }
616  llvm_unreachable("unknown object format type");
617 }
618 
620  switch (T.getArch()) {
621  case Triple::UnknownArch:
622  case Triple::aarch64:
623  case Triple::arm:
624  case Triple::thumb:
625  case Triple::x86:
626  case Triple::x86_64:
627  if (T.isOSDarwin())
628  return Triple::MachO;
629  else if (T.isOSWindows())
630  return Triple::COFF;
631  return Triple::ELF;
632 
633  case Triple::aarch64_be:
634  case Triple::arc:
635  case Triple::amdgcn:
636  case Triple::amdil:
637  case Triple::amdil64:
638  case Triple::armeb:
639  case Triple::avr:
640  case Triple::bpfeb:
641  case Triple::bpfel:
642  case Triple::hexagon:
643  case Triple::lanai:
644  case Triple::hsail:
645  case Triple::hsail64:
646  case Triple::kalimba:
647  case Triple::le32:
648  case Triple::le64:
649  case Triple::mips:
650  case Triple::mips64:
651  case Triple::mips64el:
652  case Triple::mipsel:
653  case Triple::msp430:
654  case Triple::nios2:
655  case Triple::nvptx:
656  case Triple::nvptx64:
657  case Triple::ppc64le:
658  case Triple::r600:
661  case Triple::riscv32:
662  case Triple::riscv64:
663  case Triple::shave:
664  case Triple::sparc:
665  case Triple::sparcel:
666  case Triple::sparcv9:
667  case Triple::spir:
668  case Triple::spir64:
669  case Triple::systemz:
670  case Triple::tce:
671  case Triple::tcele:
672  case Triple::thumbeb:
673  case Triple::wasm32:
674  case Triple::wasm64:
675  case Triple::xcore:
676  return Triple::ELF;
677 
678  case Triple::ppc:
679  case Triple::ppc64:
680  if (T.isOSDarwin())
681  return Triple::MachO;
682  return Triple::ELF;
683  }
684  llvm_unreachable("unknown architecture");
685 }
686 
687 /// \brief Construct a triple from the string representation provided.
688 ///
689 /// This stores the string representation and parses the various pieces into
690 /// enum members.
692  : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
693  Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
694  ObjectFormat(UnknownObjectFormat) {
695  // Do minimal parsing by hand here.
696  SmallVector<StringRef, 4> Components;
697  StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
698  if (Components.size() > 0) {
699  Arch = parseArch(Components[0]);
700  SubArch = parseSubArch(Components[0]);
701  if (Components.size() > 1) {
702  Vendor = parseVendor(Components[1]);
703  if (Components.size() > 2) {
704  OS = parseOS(Components[2]);
705  if (Components.size() > 3) {
706  Environment = parseEnvironment(Components[3]);
707  ObjectFormat = parseFormat(Components[3]);
708  }
709  }
710  }
711  }
712  if (ObjectFormat == UnknownObjectFormat)
713  ObjectFormat = getDefaultFormat(*this);
714 }
715 
716 /// \brief Construct a triple from string representations of the architecture,
717 /// vendor, and OS.
718 ///
719 /// This joins each argument into a canonical string representation and parses
720 /// them into enum members. It leaves the environment unknown and omits it from
721 /// the string representation.
722 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
723  : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
724  Arch(parseArch(ArchStr.str())),
725  SubArch(parseSubArch(ArchStr.str())),
726  Vendor(parseVendor(VendorStr.str())),
727  OS(parseOS(OSStr.str())),
728  Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
729  ObjectFormat = getDefaultFormat(*this);
730 }
731 
732 /// \brief Construct a triple from string representations of the architecture,
733 /// vendor, OS, and environment.
734 ///
735 /// This joins each argument into a canonical string representation and parses
736 /// them into enum members.
737 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
738  const Twine &EnvironmentStr)
739  : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
740  EnvironmentStr).str()),
741  Arch(parseArch(ArchStr.str())),
742  SubArch(parseSubArch(ArchStr.str())),
743  Vendor(parseVendor(VendorStr.str())),
744  OS(parseOS(OSStr.str())),
745  Environment(parseEnvironment(EnvironmentStr.str())),
746  ObjectFormat(parseFormat(EnvironmentStr.str())) {
747  if (ObjectFormat == Triple::UnknownObjectFormat)
748  ObjectFormat = getDefaultFormat(*this);
749 }
750 
751 std::string Triple::normalize(StringRef Str) {
752  bool IsMinGW32 = false;
753  bool IsCygwin = false;
754 
755  // Parse into components.
756  SmallVector<StringRef, 4> Components;
757  Str.split(Components, '-');
758 
759  // If the first component corresponds to a known architecture, preferentially
760  // use it for the architecture. If the second component corresponds to a
761  // known vendor, preferentially use it for the vendor, etc. This avoids silly
762  // component movement when a component parses as (eg) both a valid arch and a
763  // valid os.
764  ArchType Arch = UnknownArch;
765  if (Components.size() > 0)
766  Arch = parseArch(Components[0]);
767  VendorType Vendor = UnknownVendor;
768  if (Components.size() > 1)
769  Vendor = parseVendor(Components[1]);
770  OSType OS = UnknownOS;
771  if (Components.size() > 2) {
772  OS = parseOS(Components[2]);
773  IsCygwin = Components[2].startswith("cygwin");
774  IsMinGW32 = Components[2].startswith("mingw");
775  }
776  EnvironmentType Environment = UnknownEnvironment;
777  if (Components.size() > 3)
778  Environment = parseEnvironment(Components[3]);
779  ObjectFormatType ObjectFormat = UnknownObjectFormat;
780  if (Components.size() > 4)
781  ObjectFormat = parseFormat(Components[4]);
782 
783  // Note which components are already in their final position. These will not
784  // be moved.
785  bool Found[4];
786  Found[0] = Arch != UnknownArch;
787  Found[1] = Vendor != UnknownVendor;
788  Found[2] = OS != UnknownOS;
789  Found[3] = Environment != UnknownEnvironment;
790 
791  // If they are not there already, permute the components into their canonical
792  // positions by seeing if they parse as a valid architecture, and if so moving
793  // the component to the architecture position etc.
794  for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
795  if (Found[Pos])
796  continue; // Already in the canonical position.
797 
798  for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
799  // Do not reparse any components that already matched.
800  if (Idx < array_lengthof(Found) && Found[Idx])
801  continue;
802 
803  // Does this component parse as valid for the target position?
804  bool Valid = false;
805  StringRef Comp = Components[Idx];
806  switch (Pos) {
807  default: llvm_unreachable("unexpected component type!");
808  case 0:
809  Arch = parseArch(Comp);
810  Valid = Arch != UnknownArch;
811  break;
812  case 1:
813  Vendor = parseVendor(Comp);
814  Valid = Vendor != UnknownVendor;
815  break;
816  case 2:
817  OS = parseOS(Comp);
818  IsCygwin = Comp.startswith("cygwin");
819  IsMinGW32 = Comp.startswith("mingw");
820  Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
821  break;
822  case 3:
823  Environment = parseEnvironment(Comp);
824  Valid = Environment != UnknownEnvironment;
825  if (!Valid) {
826  ObjectFormat = parseFormat(Comp);
827  Valid = ObjectFormat != UnknownObjectFormat;
828  }
829  break;
830  }
831  if (!Valid)
832  continue; // Nope, try the next component.
833 
834  // Move the component to the target position, pushing any non-fixed
835  // components that are in the way to the right. This tends to give
836  // good results in the common cases of a forgotten vendor component
837  // or a wrongly positioned environment.
838  if (Pos < Idx) {
839  // Insert left, pushing the existing components to the right. For
840  // example, a-b-i386 -> i386-a-b when moving i386 to the front.
841  StringRef CurrentComponent(""); // The empty component.
842  // Replace the component we are moving with an empty component.
843  std::swap(CurrentComponent, Components[Idx]);
844  // Insert the component being moved at Pos, displacing any existing
845  // components to the right.
846  for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
847  // Skip over any fixed components.
848  while (i < array_lengthof(Found) && Found[i])
849  ++i;
850  // Place the component at the new position, getting the component
851  // that was at this position - it will be moved right.
852  std::swap(CurrentComponent, Components[i]);
853  }
854  } else if (Pos > Idx) {
855  // Push right by inserting empty components until the component at Idx
856  // reaches the target position Pos. For example, pc-a -> -pc-a when
857  // moving pc to the second position.
858  do {
859  // Insert one empty component at Idx.
860  StringRef CurrentComponent(""); // The empty component.
861  for (unsigned i = Idx; i < Components.size();) {
862  // Place the component at the new position, getting the component
863  // that was at this position - it will be moved right.
864  std::swap(CurrentComponent, Components[i]);
865  // If it was placed on top of an empty component then we are done.
866  if (CurrentComponent.empty())
867  break;
868  // Advance to the next component, skipping any fixed components.
869  while (++i < array_lengthof(Found) && Found[i])
870  ;
871  }
872  // The last component was pushed off the end - append it.
873  if (!CurrentComponent.empty())
874  Components.push_back(CurrentComponent);
875 
876  // Advance Idx to the component's new position.
877  while (++Idx < array_lengthof(Found) && Found[Idx])
878  ;
879  } while (Idx < Pos); // Add more until the final position is reached.
880  }
881  assert(Pos < Components.size() && Components[Pos] == Comp &&
882  "Component moved wrong!");
883  Found[Pos] = true;
884  break;
885  }
886  }
887 
888  // Special case logic goes here. At this point Arch, Vendor and OS have the
889  // correct values for the computed components.
890  std::string NormalizedEnvironment;
891  if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
892  StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
893  if (AndroidVersion.empty()) {
894  Components[3] = "android";
895  } else {
896  NormalizedEnvironment = Twine("android", AndroidVersion).str();
897  Components[3] = NormalizedEnvironment;
898  }
899  }
900 
901  // SUSE uses "gnueabi" to mean "gnueabihf"
902  if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI)
903  Components[3] = "gnueabihf";
904 
905  if (OS == Triple::Win32) {
906  Components.resize(4);
907  Components[2] = "windows";
908  if (Environment == UnknownEnvironment) {
909  if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
910  Components[3] = "msvc";
911  else
912  Components[3] = getObjectFormatTypeName(ObjectFormat);
913  }
914  } else if (IsMinGW32) {
915  Components.resize(4);
916  Components[2] = "windows";
917  Components[3] = "gnu";
918  } else if (IsCygwin) {
919  Components.resize(4);
920  Components[2] = "windows";
921  Components[3] = "cygnus";
922  }
923  if (IsMinGW32 || IsCygwin ||
924  (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
925  if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
926  Components.resize(5);
927  Components[4] = getObjectFormatTypeName(ObjectFormat);
928  }
929  }
930 
931  // Stick the corrected components back together to form the normalized string.
932  std::string Normalized;
933  for (unsigned i = 0, e = Components.size(); i != e; ++i) {
934  if (i) Normalized += '-';
935  Normalized += Components[i];
936  }
937  return Normalized;
938 }
939 
941  return StringRef(Data).split('-').first; // Isolate first component
942 }
943 
945  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
946  return Tmp.split('-').first; // Isolate second component
947 }
948 
950  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
951  Tmp = Tmp.split('-').second; // Strip second component
952  return Tmp.split('-').first; // Isolate third component
953 }
954 
956  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
957  Tmp = Tmp.split('-').second; // Strip second component
958  return Tmp.split('-').second; // Strip third component
959 }
960 
962  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
963  return Tmp.split('-').second; // Strip second component
964 }
965 
966 static unsigned EatNumber(StringRef &Str) {
967  assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
968  unsigned Result = 0;
969 
970  do {
971  // Consume the leading digit.
972  Result = Result*10 + (Str[0] - '0');
973 
974  // Eat the digit.
975  Str = Str.substr(1);
976  } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
977 
978  return Result;
979 }
980 
981 static void parseVersionFromName(StringRef Name, unsigned &Major,
982  unsigned &Minor, unsigned &Micro) {
983  // Any unset version defaults to 0.
984  Major = Minor = Micro = 0;
985 
986  // Parse up to three components.
987  unsigned *Components[3] = {&Major, &Minor, &Micro};
988  for (unsigned i = 0; i != 3; ++i) {
989  if (Name.empty() || Name[0] < '0' || Name[0] > '9')
990  break;
991 
992  // Consume the leading number.
993  *Components[i] = EatNumber(Name);
994 
995  // Consume the separator, if present.
996  if (Name.startswith("."))
997  Name = Name.substr(1);
998  }
999 }
1000 
1001 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
1002  unsigned &Micro) const {
1003  StringRef EnvironmentName = getEnvironmentName();
1004  StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
1005  if (EnvironmentName.startswith(EnvironmentTypeName))
1006  EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
1007 
1008  parseVersionFromName(EnvironmentName, Major, Minor, Micro);
1009 }
1010 
1011 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
1012  unsigned &Micro) const {
1013  StringRef OSName = getOSName();
1014  // Assume that the OS portion of the triple starts with the canonical name.
1015  StringRef OSTypeName = getOSTypeName(getOS());
1016  if (OSName.startswith(OSTypeName))
1017  OSName = OSName.substr(OSTypeName.size());
1018  else if (getOS() == MacOSX)
1019  OSName.consume_front("macos");
1020 
1021  parseVersionFromName(OSName, Major, Minor, Micro);
1022 }
1023 
1024 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
1025  unsigned &Micro) const {
1026  getOSVersion(Major, Minor, Micro);
1027 
1028  switch (getOS()) {
1029  default: llvm_unreachable("unexpected OS for Darwin triple");
1030  case Darwin:
1031  // Default to darwin8, i.e., MacOSX 10.4.
1032  if (Major == 0)
1033  Major = 8;
1034  // Darwin version numbers are skewed from OS X versions.
1035  if (Major < 4)
1036  return false;
1037  Micro = 0;
1038  Minor = Major - 4;
1039  Major = 10;
1040  break;
1041  case MacOSX:
1042  // Default to 10.4.
1043  if (Major == 0) {
1044  Major = 10;
1045  Minor = 4;
1046  }
1047  if (Major != 10)
1048  return false;
1049  break;
1050  case IOS:
1051  case TvOS:
1052  case WatchOS:
1053  // Ignore the version from the triple. This is only handled because the
1054  // the clang driver combines OS X and IOS support into a common Darwin
1055  // toolchain that wants to know the OS X version number even when targeting
1056  // IOS.
1057  Major = 10;
1058  Minor = 4;
1059  Micro = 0;
1060  break;
1061  }
1062  return true;
1063 }
1064 
1065 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
1066  unsigned &Micro) const {
1067  switch (getOS()) {
1068  default: llvm_unreachable("unexpected OS for Darwin triple");
1069  case Darwin:
1070  case MacOSX:
1071  // Ignore the version from the triple. This is only handled because the
1072  // the clang driver combines OS X and IOS support into a common Darwin
1073  // toolchain that wants to know the iOS version number even when targeting
1074  // OS X.
1075  Major = 5;
1076  Minor = 0;
1077  Micro = 0;
1078  break;
1079  case IOS:
1080  case TvOS:
1081  getOSVersion(Major, Minor, Micro);
1082  // Default to 5.0 (or 7.0 for arm64).
1083  if (Major == 0)
1084  Major = (getArch() == aarch64) ? 7 : 5;
1085  break;
1086  case WatchOS:
1087  llvm_unreachable("conflicting triple info");
1088  }
1089 }
1090 
1091 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
1092  unsigned &Micro) const {
1093  switch (getOS()) {
1094  default: llvm_unreachable("unexpected OS for Darwin triple");
1095  case Darwin:
1096  case MacOSX:
1097  // Ignore the version from the triple. This is only handled because the
1098  // the clang driver combines OS X and IOS support into a common Darwin
1099  // toolchain that wants to know the iOS version number even when targeting
1100  // OS X.
1101  Major = 2;
1102  Minor = 0;
1103  Micro = 0;
1104  break;
1105  case WatchOS:
1106  getOSVersion(Major, Minor, Micro);
1107  if (Major == 0)
1108  Major = 2;
1109  break;
1110  case IOS:
1111  llvm_unreachable("conflicting triple info");
1112  }
1113 }
1114 
1115 void Triple::setTriple(const Twine &Str) {
1116  *this = Triple(Str);
1117 }
1118 
1121 }
1122 
1125 }
1126 
1128  setOSName(getOSTypeName(Kind));
1129 }
1130 
1132  if (ObjectFormat == getDefaultFormat(*this))
1134 
1136  getObjectFormatTypeName(ObjectFormat)).str());
1137 }
1138 
1140  if (Environment == UnknownEnvironment)
1142 
1143  setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1144  getObjectFormatTypeName(Kind)).str());
1145 }
1146 
1148  // Work around a miscompilation bug for Twines in gcc 4.0.3.
1150  Triple += Str;
1151  Triple += "-";
1152  Triple += getVendorName();
1153  Triple += "-";
1154  Triple += getOSAndEnvironmentName();
1155  setTriple(Triple);
1156 }
1157 
1159  setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1160 }
1161 
1163  if (hasEnvironment())
1164  setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1165  "-" + getEnvironmentName());
1166  else
1167  setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1168 }
1169 
1171  setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1172  "-" + Str);
1173 }
1174 
1176  setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1177 }
1178 
1180  switch (Arch) {
1182  return 0;
1183 
1184  case llvm::Triple::avr:
1185  case llvm::Triple::msp430:
1186  return 16;
1187 
1188  case llvm::Triple::arc:
1189  case llvm::Triple::arm:
1190  case llvm::Triple::armeb:
1191  case llvm::Triple::hexagon:
1192  case llvm::Triple::le32:
1193  case llvm::Triple::mips:
1194  case llvm::Triple::mipsel:
1195  case llvm::Triple::nios2:
1196  case llvm::Triple::nvptx:
1197  case llvm::Triple::ppc:
1198  case llvm::Triple::r600:
1199  case llvm::Triple::riscv32:
1200  case llvm::Triple::sparc:
1201  case llvm::Triple::sparcel:
1202  case llvm::Triple::tce:
1203  case llvm::Triple::tcele:
1204  case llvm::Triple::thumb:
1205  case llvm::Triple::thumbeb:
1206  case llvm::Triple::x86:
1207  case llvm::Triple::xcore:
1208  case llvm::Triple::amdil:
1209  case llvm::Triple::hsail:
1210  case llvm::Triple::spir:
1211  case llvm::Triple::kalimba:
1212  case llvm::Triple::lanai:
1213  case llvm::Triple::shave:
1214  case llvm::Triple::wasm32:
1216  return 32;
1217 
1218  case llvm::Triple::aarch64:
1220  case llvm::Triple::amdgcn:
1221  case llvm::Triple::bpfel:
1222  case llvm::Triple::bpfeb:
1223  case llvm::Triple::le64:
1224  case llvm::Triple::mips64:
1226  case llvm::Triple::nvptx64:
1227  case llvm::Triple::ppc64:
1228  case llvm::Triple::ppc64le:
1229  case llvm::Triple::riscv64:
1230  case llvm::Triple::sparcv9:
1231  case llvm::Triple::systemz:
1232  case llvm::Triple::x86_64:
1233  case llvm::Triple::amdil64:
1234  case llvm::Triple::hsail64:
1235  case llvm::Triple::spir64:
1236  case llvm::Triple::wasm64:
1238  return 64;
1239  }
1240  llvm_unreachable("Invalid architecture value");
1241 }
1242 
1243 bool Triple::isArch64Bit() const {
1244  return getArchPointerBitWidth(getArch()) == 64;
1245 }
1246 
1247 bool Triple::isArch32Bit() const {
1248  return getArchPointerBitWidth(getArch()) == 32;
1249 }
1250 
1251 bool Triple::isArch16Bit() const {
1252  return getArchPointerBitWidth(getArch()) == 16;
1253 }
1254 
1256  Triple T(*this);
1257  switch (getArch()) {
1258  case Triple::UnknownArch:
1259  case Triple::amdgcn:
1260  case Triple::avr:
1261  case Triple::bpfel:
1262  case Triple::bpfeb:
1263  case Triple::msp430:
1264  case Triple::systemz:
1265  case Triple::ppc64le:
1266  T.setArch(UnknownArch);
1267  break;
1268 
1269  case Triple::amdil:
1270  case Triple::hsail:
1271  case Triple::spir:
1272  case Triple::arc:
1273  case Triple::arm:
1274  case Triple::armeb:
1275  case Triple::hexagon:
1276  case Triple::kalimba:
1277  case Triple::le32:
1278  case Triple::mips:
1279  case Triple::mipsel:
1280  case Triple::nios2:
1281  case Triple::nvptx:
1282  case Triple::ppc:
1283  case Triple::r600:
1284  case Triple::riscv32:
1285  case Triple::sparc:
1286  case Triple::sparcel:
1287  case Triple::tce:
1288  case Triple::tcele:
1289  case Triple::thumb:
1290  case Triple::thumbeb:
1291  case Triple::x86:
1292  case Triple::xcore:
1293  case Triple::lanai:
1294  case Triple::shave:
1295  case Triple::wasm32:
1297  // Already 32-bit.
1298  break;
1299 
1300  case Triple::aarch64: T.setArch(Triple::arm); break;
1301  case Triple::aarch64_be: T.setArch(Triple::armeb); break;
1302  case Triple::le64: T.setArch(Triple::le32); break;
1303  case Triple::mips64: T.setArch(Triple::mips); break;
1304  case Triple::mips64el: T.setArch(Triple::mipsel); break;
1305  case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1306  case Triple::ppc64: T.setArch(Triple::ppc); break;
1307  case Triple::sparcv9: T.setArch(Triple::sparc); break;
1308  case Triple::riscv64: T.setArch(Triple::riscv32); break;
1309  case Triple::x86_64: T.setArch(Triple::x86); break;
1310  case Triple::amdil64: T.setArch(Triple::amdil); break;
1311  case Triple::hsail64: T.setArch(Triple::hsail); break;
1312  case Triple::spir64: T.setArch(Triple::spir); break;
1313  case Triple::wasm64: T.setArch(Triple::wasm32); break;
1315  }
1316  return T;
1317 }
1318 
1320  Triple T(*this);
1321  switch (getArch()) {
1322  case Triple::UnknownArch:
1323  case Triple::arc:
1324  case Triple::avr:
1325  case Triple::hexagon:
1326  case Triple::kalimba:
1327  case Triple::lanai:
1328  case Triple::msp430:
1329  case Triple::nios2:
1330  case Triple::r600:
1331  case Triple::tce:
1332  case Triple::tcele:
1333  case Triple::xcore:
1334  case Triple::sparcel:
1335  case Triple::shave:
1336  T.setArch(UnknownArch);
1337  break;
1338 
1339  case Triple::aarch64:
1340  case Triple::aarch64_be:
1341  case Triple::bpfel:
1342  case Triple::bpfeb:
1343  case Triple::le64:
1344  case Triple::amdil64:
1345  case Triple::amdgcn:
1346  case Triple::hsail64:
1347  case Triple::spir64:
1348  case Triple::mips64:
1349  case Triple::mips64el:
1350  case Triple::nvptx64:
1351  case Triple::ppc64:
1352  case Triple::ppc64le:
1353  case Triple::riscv64:
1354  case Triple::sparcv9:
1355  case Triple::systemz:
1356  case Triple::x86_64:
1357  case Triple::wasm64:
1359  // Already 64-bit.
1360  break;
1361 
1362  case Triple::arm: T.setArch(Triple::aarch64); break;
1363  case Triple::armeb: T.setArch(Triple::aarch64_be); break;
1364  case Triple::le32: T.setArch(Triple::le64); break;
1365  case Triple::mips: T.setArch(Triple::mips64); break;
1366  case Triple::mipsel: T.setArch(Triple::mips64el); break;
1367  case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1368  case Triple::ppc: T.setArch(Triple::ppc64); break;
1369  case Triple::sparc: T.setArch(Triple::sparcv9); break;
1370  case Triple::riscv32: T.setArch(Triple::riscv64); break;
1371  case Triple::x86: T.setArch(Triple::x86_64); break;
1372  case Triple::amdil: T.setArch(Triple::amdil64); break;
1373  case Triple::hsail: T.setArch(Triple::hsail64); break;
1374  case Triple::spir: T.setArch(Triple::spir64); break;
1375  case Triple::thumb: T.setArch(Triple::aarch64); break;
1376  case Triple::thumbeb: T.setArch(Triple::aarch64_be); break;
1377  case Triple::wasm32: T.setArch(Triple::wasm64); break;
1379  }
1380  return T;
1381 }
1382 
1384  Triple T(*this);
1385  // Already big endian.
1386  if (!isLittleEndian())
1387  return T;
1388  switch (getArch()) {
1389  case Triple::UnknownArch:
1390  case Triple::amdgcn:
1391  case Triple::amdil64:
1392  case Triple::amdil:
1393  case Triple::avr:
1394  case Triple::hexagon:
1395  case Triple::hsail64:
1396  case Triple::hsail:
1397  case Triple::kalimba:
1398  case Triple::le32:
1399  case Triple::le64:
1400  case Triple::msp430:
1401  case Triple::nios2:
1402  case Triple::nvptx64:
1403  case Triple::nvptx:
1404  case Triple::r600:
1405  case Triple::riscv32:
1406  case Triple::riscv64:
1407  case Triple::shave:
1408  case Triple::spir64:
1409  case Triple::spir:
1410  case Triple::wasm32:
1411  case Triple::wasm64:
1412  case Triple::x86:
1413  case Triple::x86_64:
1414  case Triple::xcore:
1417 
1418  // ARM is intentionally unsupported here, changing the architecture would
1419  // drop any arch suffixes.
1420  case Triple::arm:
1421  case Triple::thumb:
1422  T.setArch(UnknownArch);
1423  break;
1424 
1425  case Triple::tcele: T.setArch(Triple::tce); break;
1426  case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1427  case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1428  case Triple::mips64el:T.setArch(Triple::mips64); break;
1429  case Triple::mipsel: T.setArch(Triple::mips); break;
1430  case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1431  case Triple::sparcel: T.setArch(Triple::sparc); break;
1432  default:
1433  llvm_unreachable("getBigEndianArchVariant: unknown triple.");
1434  }
1435  return T;
1436 }
1437 
1439  Triple T(*this);
1440  if (isLittleEndian())
1441  return T;
1442 
1443  switch (getArch()) {
1444  case Triple::UnknownArch:
1445  case Triple::lanai:
1446  case Triple::ppc:
1447  case Triple::sparcv9:
1448  case Triple::systemz:
1449 
1450  // ARM is intentionally unsupported here, changing the architecture would
1451  // drop any arch suffixes.
1452  case Triple::armeb:
1453  case Triple::thumbeb:
1454  T.setArch(UnknownArch);
1455  break;
1456 
1457  case Triple::tce: T.setArch(Triple::tcele); break;
1458  case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1459  case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1460  case Triple::mips64: T.setArch(Triple::mips64el); break;
1461  case Triple::mips: T.setArch(Triple::mipsel); break;
1462  case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1463  case Triple::sparc: T.setArch(Triple::sparcel); break;
1464  default:
1465  llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
1466  }
1467  return T;
1468 }
1469 
1471  switch (getArch()) {
1472  case Triple::aarch64:
1473  case Triple::amdgcn:
1474  case Triple::amdil64:
1475  case Triple::amdil:
1476  case Triple::arm:
1477  case Triple::avr:
1478  case Triple::bpfel:
1479  case Triple::hexagon:
1480  case Triple::hsail64:
1481  case Triple::hsail:
1482  case Triple::kalimba:
1483  case Triple::le32:
1484  case Triple::le64:
1485  case Triple::mips64el:
1486  case Triple::mipsel:
1487  case Triple::msp430:
1488  case Triple::nios2:
1489  case Triple::nvptx64:
1490  case Triple::nvptx:
1491  case Triple::ppc64le:
1492  case Triple::r600:
1493  case Triple::riscv32:
1494  case Triple::riscv64:
1495  case Triple::shave:
1496  case Triple::sparcel:
1497  case Triple::spir64:
1498  case Triple::spir:
1499  case Triple::thumb:
1500  case Triple::wasm32:
1501  case Triple::wasm64:
1502  case Triple::x86:
1503  case Triple::x86_64:
1504  case Triple::xcore:
1505  case Triple::tcele:
1508  return true;
1509  default:
1510  return false;
1511  }
1512 }
1513 
1514 bool Triple::isCompatibleWith(const Triple &Other) const {
1515  // ARM and Thumb triples are compatible, if subarch, vendor and OS match.
1516  if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) ||
1517  (getArch() == Triple::arm && Other.getArch() == Triple::thumb) ||
1518  (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) ||
1519  (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) {
1520  if (getVendor() == Triple::Apple)
1521  return getSubArch() == Other.getSubArch() &&
1522  getVendor() == Other.getVendor() && getOS() == Other.getOS();
1523  else
1524  return getSubArch() == Other.getSubArch() &&
1525  getVendor() == Other.getVendor() && getOS() == Other.getOS() &&
1526  getEnvironment() == Other.getEnvironment() &&
1527  getObjectFormat() == Other.getObjectFormat();
1528  }
1529 
1530  // If vendor is apple, ignore the version number.
1531  if (getVendor() == Triple::Apple)
1532  return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
1533  getVendor() == Other.getVendor() && getOS() == Other.getOS();
1534 
1535  return *this == Other;
1536 }
1537 
1538 std::string Triple::merge(const Triple &Other) const {
1539  // If vendor is apple, pick the triple with the larger version number.
1540  if (getVendor() == Triple::Apple)
1541  if (Other.isOSVersionLT(*this))
1542  return str();
1543 
1544  return Other.str();
1545 }
1546 
1548  if (MArch.empty())
1549  MArch = getArchName();
1550  MArch = ARM::getCanonicalArchName(MArch);
1551 
1552  // Some defaults are forced.
1553  switch (getOS()) {
1554  case llvm::Triple::FreeBSD:
1555  case llvm::Triple::NetBSD:
1556  if (!MArch.empty() && MArch == "v6")
1557  return "arm1176jzf-s";
1558  break;
1559  case llvm::Triple::Win32:
1560  // FIXME: this is invalid for WindowsCE
1561  return "cortex-a9";
1562  case llvm::Triple::MacOSX:
1563  case llvm::Triple::IOS:
1564  case llvm::Triple::WatchOS:
1565  case llvm::Triple::TvOS:
1566  if (MArch == "v7k")
1567  return "cortex-a7";
1568  break;
1569  default:
1570  break;
1571  }
1572 
1573  if (MArch.empty())
1574  return StringRef();
1575 
1576  StringRef CPU = ARM::getDefaultCPU(MArch);
1577  if (!CPU.empty() && !CPU.equals("invalid"))
1578  return CPU;
1579 
1580  // If no specific architecture version is requested, return the minimum CPU
1581  // required by the OS and environment.
1582  switch (getOS()) {
1583  case llvm::Triple::NetBSD:
1584  switch (getEnvironment()) {
1586  case llvm::Triple::GNUEABI:
1587  case llvm::Triple::EABIHF:
1588  case llvm::Triple::EABI:
1589  return "arm926ej-s";
1590  default:
1591  return "strongarm";
1592  }
1593  case llvm::Triple::NaCl:
1594  case llvm::Triple::OpenBSD:
1595  return "cortex-a8";
1596  default:
1597  switch (getEnvironment()) {
1598  case llvm::Triple::EABIHF:
1601  return "arm1176jzf-s";
1602  default:
1603  return "arm7tdmi";
1604  }
1605  }
1606 
1607  llvm_unreachable("invalid arch name");
1608 }
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
Definition: Triple.h:470
void getiOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const
getiOSVersion - Parse the version number as with getOSVersion.
Definition: Triple.cpp:1065
static StringRef getVendorTypeName(VendorType Kind)
getVendorTypeName - Get the canonical name for the Kind vendor.
Definition: Triple.cpp:152
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
static Triple::ArchType parseBPFArch(StringRef ArchName)
Definition: Triple.cpp:244
OSType getOS() const
getOS - Get the parsed operating system type of this triple.
Definition: Triple.h:294
void setVendor(VendorType Kind)
setVendor - Set the vendor (second) component of the triple to a known type.
Definition: Triple.cpp:1123
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
bool isArch16Bit() const
Test whether the architecture is 16-bit.
Definition: Triple.cpp:1251
bool hasEnvironment() const
hasEnvironment - Does this triple have the optional environment (fourth) component?
Definition: Triple.h:298
static Triple::ArchType parseARMArch(StringRef ArchName)
Definition: Triple.cpp:316
StringRef getDefaultCPU(StringRef Arch)
void setOS(OSType Kind)
setOS - Set the operating system (third) component of the triple to a known type. ...
Definition: Triple.cpp:1127
void setEnvironment(EnvironmentType Kind)
setEnvironment - Set the environment (fourth) component of the triple to a known type.
Definition: Triple.cpp:1131
void getEnvironmentVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const
Parse the version number from the OS name component of the triple, if present.
Definition: Triple.cpp:1001
StringRef getARMCPUForArch(StringRef Arch=StringRef()) const
Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
Definition: Triple.cpp:1547
static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch)
Definition: Triple.cpp:1179
static unsigned EatNumber(StringRef &Str)
Definition: Triple.cpp:966
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static StringRef getArchTypeName(ArchType Kind)
getArchTypeName - Get the canonical name for the Kind architecture.
Definition: Triple.cpp:20
ISAKind parseArchISA(StringRef Arch)
void setVendorName(StringRef Str)
setVendorName - Set the vendor (second) component of the triple by name.
Definition: Triple.cpp:1158
static Triple::OSType parseOS(StringRef OSName)
Definition: Triple.cpp:471
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & EndsWith(const char(&S)[N], const T &Value)
Definition: StringSwitch.h:85
Triple()
Default constructor is the same as an empty string and leaves all triple fields unknown.
Definition: Triple.h:247
static bool startswith(StringRef Magic, const char(&S)[N])
Definition: Magic.cpp:29
SubArchType getSubArch() const
getSubArch - get the parsed subarchitecture type for this triple.
Definition: Triple.h:288
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & Case(const char(&S)[N], const T &Value)
Definition: StringSwitch.h:74
static const bool IsLittleEndianHost
Definition: Host.h:50
LLVM_ATTRIBUTE_ALWAYS_INLINE bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition: StringRef.h:678
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:285
#define T
bool isArch32Bit() const
Test whether the architecture is 32-bit.
Definition: Triple.cpp:1247
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:598
static StringRef getOSTypeName(OSType Kind)
getOSTypeName - Get the canonical name for the Kind operating system.
Definition: Triple.cpp:176
const std::string & str() const
Definition: Triple.h:354
unsigned parseArchVersion(StringRef Arch)
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:562
void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const
getOSVersion - Parse the version number from the OS name component of the triple, if present...
Definition: Triple.cpp:1011
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:43
void setObjectFormat(ObjectFormatType Kind)
setObjectFormat - Set the object file format
Definition: Triple.cpp:1139
StringRef getOSAndEnvironmentName() const
getOSAndEnvironmentName - Get the operating system and optional environment components as a single st...
Definition: Triple.cpp:961
llvm::Triple get32BitArchVariant() const
Form a triple with a 32-bit variant of the current architecture.
Definition: Triple.cpp:1255
static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName)
Definition: Triple.cpp:533
bool isLittleEndian() const
Tests whether the target triple is little endian.
Definition: Triple.cpp:1470
VendorType getVendor() const
getVendor - Get the parsed vendor type of this triple.
Definition: Triple.h:291
void setEnvironmentName(StringRef Str)
setEnvironmentName - Set the optional environment (fourth) component of the triple by name...
Definition: Triple.cpp:1170
llvm::Triple getBigEndianArchVariant() const
Form a triple with a big endian variant of the current architecture.
Definition: Triple.cpp:1383
void setTriple(const Twine &Str)
setTriple - Set all components to the new triple Str.
Definition: Triple.cpp:1115
bool isCompatibleWith(const Triple &Other) const
Test whether target triples are compatible.
Definition: Triple.cpp:1514
static StringRef getArchTypePrefix(ArchType Kind)
getArchTypePrefix - Get the "prefix" canonical name for the Kind architecture.
Definition: Triple.cpp:79
void getWatchOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const
getWatchOSVersion - Parse the version number as with getOSVersion.
Definition: Triple.cpp:1091
void setArchName(StringRef Str)
setArchName - Set the architecture (first) component of the triple by name.
Definition: Triple.cpp:1147
static Triple::ObjectFormatType getDefaultFormat(const Triple &T)
Definition: Triple.cpp:619
static Triple::SubArchType parseSubArch(StringRef SubArchName)
Definition: Triple.cpp:542
void setOSName(StringRef Str)
setOSName - Set the operating system (third) component of the triple by name.
Definition: Triple.cpp:1162
EndianKind parseArchEndian(StringRef Arch)
static Triple::VendorType parseVendor(StringRef VendorName)
Definition: Triple.cpp:451
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVM_ATTRIBUTE_ALWAYS_INLINE R Default(const T &Value) const
Definition: StringSwitch.h:244
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
StringRef getArchName() const
getArchName - Get the architecture (first) component of the triple.
Definition: Triple.cpp:940
bool getMacOSXVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const
getMacOSXVersion - Parse the version number as with getOSVersion and then translate generic "darwin" ...
Definition: Triple.cpp:1024
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:727
static ArchType getArchTypeForLLVMName(StringRef Str)
getArchTypeForLLVMName - The canonical type for the given LLVM architecture name (e.g., "x86").
Definition: Triple.cpp:259
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:674
StringRef getOSName() const
getOSName - Get the operating system (third) component of the triple.
Definition: Triple.cpp:949
cl::opt< std::string > MArch("march", cl::desc("Architecture to generate code for (see --version)"))
EnvironmentType getEnvironment() const
getEnvironment - Get the parsed environment type of this triple.
Definition: Triple.h:303
std::string merge(const Triple &Other) const
Merge target triples.
Definition: Triple.cpp:1538
ProfileKind parseArchProfile(StringRef Arch)
std::string normalize() const
Return the normalized form of this triple&#39;s string.
Definition: Triple.h:278
StringRef getEnvironmentName() const
getEnvironmentName - Get the optional environment (fourth) component of the triple, or "" if empty.
Definition: Triple.cpp:955
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:923
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:169
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & Cases(const char(&S0)[N0], const char(&S1)[N1], const T &Value)
Definition: StringSwitch.h:107
llvm::Triple getLittleEndianArchVariant() const
Form a triple with a little endian variant of the current architecture.
Definition: Triple.cpp:1438
ObjectFormatType getObjectFormat() const
getFormat - Get the object format for this triple.
Definition: Triple.h:315
void setOSAndEnvironmentName(StringRef Str)
setOSAndEnvironmentName - Set the operating system and optional environment components with a single ...
Definition: Triple.cpp:1175
bool isArch64Bit() const
Test whether the architecture is 64-bit.
Definition: Triple.cpp:1243
static void parseVersionFromName(StringRef Name, unsigned &Major, unsigned &Minor, unsigned &Micro)
Definition: Triple.cpp:981
StringRef getVendorName() const
getVendorName - Get the vendor (second) component of the triple.
Definition: Triple.cpp:944
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
static Triple::ArchType parseArch(StringRef ArchName)
Definition: Triple.cpp:381
ArchKind parseArch(StringRef Arch)
const unsigned Kind
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ObjectFormatType
Definition: Triple.h:211
llvm::Triple get64BitArchVariant() const
Form a triple with a 64-bit variant of the current architecture.
Definition: Triple.cpp:1319
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
StringRef getCanonicalArchName(StringRef Arch)
bool isOSVersionLT(unsigned Major, unsigned Minor=0, unsigned Micro=0) const
isOSVersionLT - Helper function for doing comparisons against version numbers included in the target ...
Definition: Triple.h:403
static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName)
Definition: Triple.cpp:508
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & StartsWith(const char(&S)[N], const T &Value)
Definition: StringSwitch.h:96
const uint64_t Version
Definition: InstrProf.h:867
void setArch(ArchType Kind)
setArch - Set the architecture (first) component of the triple to a known type.
Definition: Triple.cpp:1119
static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind)
Definition: Triple.cpp:608
void resize(size_type N)
Definition: SmallVector.h:355
static StringRef getEnvironmentTypeName(EnvironmentType Kind)
getEnvironmentTypeName - Get the canonical name for the Kind environment.
Definition: Triple.cpp:216