1 //===--- Triple.cpp - Target triple helper class --------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/Triple.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringSwitch.h"
14 #include "llvm/Support/ErrorHandling.h"
15 #include "llvm/Support/TargetParser.h"
16 #include "llvm/Support/Host.h"
20 StringRef Triple::getArchTypeName(ArchType Kind) {
22 case UnknownArch: return "unknown";
24 case aarch64: return "aarch64";
25 case aarch64_be: return "aarch64_be";
26 case arm: return "arm";
27 case armeb: return "armeb";
28 case avr: return "avr";
29 case bpfel: return "bpfel";
30 case bpfeb: return "bpfeb";
31 case hexagon: return "hexagon";
32 case mips: return "mips";
33 case mipsel: return "mipsel";
34 case mips64: return "mips64";
35 case mips64el: return "mips64el";
36 case msp430: return "msp430";
37 case ppc64: return "powerpc64";
38 case ppc64le: return "powerpc64le";
39 case ppc: return "powerpc";
40 case r600: return "r600";
41 case amdgcn: return "amdgcn";
42 case riscv32: return "riscv32";
43 case riscv64: return "riscv64";
44 case sparc: return "sparc";
45 case sparcv9: return "sparcv9";
46 case sparcel: return "sparcel";
47 case systemz: return "s390x";
48 case tce: return "tce";
49 case tcele: return "tcele";
50 case thumb: return "thumb";
51 case thumbeb: return "thumbeb";
52 case x86: return "i386";
53 case x86_64: return "x86_64";
54 case xcore: return "xcore";
55 case nvptx: return "nvptx";
56 case nvptx64: return "nvptx64";
57 case le32: return "le32";
58 case le64: return "le64";
59 case amdil: return "amdil";
60 case amdil64: return "amdil64";
61 case hsail: return "hsail";
62 case hsail64: return "hsail64";
63 case spir: return "spir";
64 case spir64: return "spir64";
65 case kalimba: return "kalimba";
66 case lanai: return "lanai";
67 case shave: return "shave";
68 case wasm32: return "wasm32";
69 case wasm64: return "wasm64";
70 case renderscript32: return "renderscript32";
71 case renderscript64: return "renderscript64";
74 llvm_unreachable("Invalid ArchType!");
77 StringRef Triple::getArchTypePrefix(ArchType Kind) {
83 case aarch64_be: return "aarch64";
88 case thumbeb: return "arm";
90 case avr: return "avr";
94 case ppc: return "ppc";
99 case mips64el: return "mips";
101 case hexagon: return "hexagon";
103 case amdgcn: return "amdgcn";
104 case r600: return "r600";
107 case bpfeb: return "bpf";
111 case sparc: return "sparc";
113 case systemz: return "s390";
116 case x86_64: return "x86";
118 case xcore: return "xcore";
120 // NVPTX intrinsics are namespaced under nvvm.
121 case nvptx: return "nvvm";
122 case nvptx64: return "nvvm";
124 case le32: return "le32";
125 case le64: return "le64";
128 case amdil64: return "amdil";
131 case hsail64: return "hsail";
134 case spir64: return "spir";
135 case kalimba: return "kalimba";
136 case lanai: return "lanai";
137 case shave: return "shave";
139 case wasm64: return "wasm";
142 case riscv64: return "riscv";
146 StringRef Triple::getVendorTypeName(VendorType Kind) {
148 case UnknownVendor: return "unknown";
150 case Apple: return "apple";
151 case PC: return "pc";
152 case SCEI: return "scei";
153 case BGP: return "bgp";
154 case BGQ: return "bgq";
155 case Freescale: return "fsl";
156 case IBM: return "ibm";
157 case ImaginationTechnologies: return "img";
158 case MipsTechnologies: return "mti";
159 case NVIDIA: return "nvidia";
160 case CSR: return "csr";
161 case Myriad: return "myriad";
162 case AMD: return "amd";
163 case Mesa: return "mesa";
166 llvm_unreachable("Invalid VendorType!");
169 StringRef Triple::getOSTypeName(OSType Kind) {
171 case UnknownOS: return "unknown";
173 case CloudABI: return "cloudabi";
174 case Darwin: return "darwin";
175 case DragonFly: return "dragonfly";
176 case FreeBSD: return "freebsd";
177 case Fuchsia: return "fuchsia";
178 case IOS: return "ios";
179 case KFreeBSD: return "kfreebsd";
180 case Linux: return "linux";
181 case Lv2: return "lv2";
182 case MacOSX: return "macosx";
183 case NetBSD: return "netbsd";
184 case OpenBSD: return "openbsd";
185 case Solaris: return "solaris";
186 case Win32: return "windows";
187 case Haiku: return "haiku";
188 case Minix: return "minix";
189 case RTEMS: return "rtems";
190 case NaCl: return "nacl";
191 case CNK: return "cnk";
192 case Bitrig: return "bitrig";
193 case AIX: return "aix";
194 case CUDA: return "cuda";
195 case NVCL: return "nvcl";
196 case AMDHSA: return "amdhsa";
197 case PS4: return "ps4";
198 case ELFIAMCU: return "elfiamcu";
199 case TvOS: return "tvos";
200 case WatchOS: return "watchos";
201 case Mesa3D: return "mesa3d";
202 case Contiki: return "contiki";
205 llvm_unreachable("Invalid OSType");
208 StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
210 case UnknownEnvironment: return "unknown";
211 case GNU: return "gnu";
212 case GNUABI64: return "gnuabi64";
213 case GNUEABIHF: return "gnueabihf";
214 case GNUEABI: return "gnueabi";
215 case GNUX32: return "gnux32";
216 case CODE16: return "code16";
217 case EABI: return "eabi";
218 case EABIHF: return "eabihf";
219 case Android: return "android";
220 case Musl: return "musl";
221 case MuslEABI: return "musleabi";
222 case MuslEABIHF: return "musleabihf";
223 case MSVC: return "msvc";
224 case Itanium: return "itanium";
225 case Cygnus: return "cygnus";
226 case AMDOpenCL: return "amdopencl";
227 case CoreCLR: return "coreclr";
228 case OpenCL: return "opencl";
231 llvm_unreachable("Invalid EnvironmentType!");
234 static Triple::ArchType parseBPFArch(StringRef ArchName) {
235 if (ArchName.equals("bpf")) {
236 if (sys::IsLittleEndianHost)
237 return Triple::bpfel;
239 return Triple::bpfeb;
240 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
241 return Triple::bpfeb;
242 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
243 return Triple::bpfel;
245 return Triple::UnknownArch;
249 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
250 Triple::ArchType BPFArch(parseBPFArch(Name));
251 return StringSwitch<Triple::ArchType>(Name)
252 .Case("aarch64", aarch64)
253 .Case("aarch64_be", aarch64_be)
254 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
256 .Case("armeb", armeb)
258 .StartsWith("bpf", BPFArch)
260 .Case("mipsel", mipsel)
261 .Case("mips64", mips64)
262 .Case("mips64el", mips64el)
263 .Case("msp430", msp430)
264 .Case("ppc64", ppc64)
267 .Case("ppc64le", ppc64le)
269 .Case("amdgcn", amdgcn)
270 .Case("riscv32", riscv32)
271 .Case("riscv64", riscv64)
272 .Case("hexagon", hexagon)
273 .Case("sparc", sparc)
274 .Case("sparcel", sparcel)
275 .Case("sparcv9", sparcv9)
276 .Case("systemz", systemz)
278 .Case("tcele", tcele)
279 .Case("thumb", thumb)
280 .Case("thumbeb", thumbeb)
282 .Case("x86-64", x86_64)
283 .Case("xcore", xcore)
284 .Case("nvptx", nvptx)
285 .Case("nvptx64", nvptx64)
288 .Case("amdil", amdil)
289 .Case("amdil64", amdil64)
290 .Case("hsail", hsail)
291 .Case("hsail64", hsail64)
293 .Case("spir64", spir64)
294 .Case("kalimba", kalimba)
295 .Case("lanai", lanai)
296 .Case("shave", shave)
297 .Case("wasm32", wasm32)
298 .Case("wasm64", wasm64)
299 .Case("renderscript32", renderscript32)
300 .Case("renderscript64", renderscript64)
301 .Default(UnknownArch);
304 static Triple::ArchType parseARMArch(StringRef ArchName) {
305 unsigned ISA = ARM::parseArchISA(ArchName);
306 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
308 Triple::ArchType arch = Triple::UnknownArch;
310 case ARM::EK_LITTLE: {
316 arch = Triple::thumb;
318 case ARM::IK_AARCH64:
319 arch = Triple::aarch64;
327 arch = Triple::armeb;
330 arch = Triple::thumbeb;
332 case ARM::IK_AARCH64:
333 arch = Triple::aarch64_be;
340 ArchName = ARM::getCanonicalArchName(ArchName);
341 if (ArchName.empty())
342 return Triple::UnknownArch;
344 // Thumb only exists in v4+
345 if (ISA == ARM::IK_THUMB &&
346 (ArchName.startswith("v2") || ArchName.startswith("v3")))
347 return Triple::UnknownArch;
349 // Thumb only for v6m
350 unsigned Profile = ARM::parseArchProfile(ArchName);
351 unsigned Version = ARM::parseArchVersion(ArchName);
352 if (Profile == ARM::PK_M && Version == 6) {
353 if (ENDIAN == ARM::EK_BIG)
354 return Triple::thumbeb;
356 return Triple::thumb;
362 static Triple::ArchType parseArch(StringRef ArchName) {
363 auto AT = StringSwitch<Triple::ArchType>(ArchName)
364 .Cases("i386", "i486", "i586", "i686", Triple::x86)
365 // FIXME: Do we need to support these?
366 .Cases("i786", "i886", "i986", Triple::x86)
367 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
368 .Cases("powerpc", "ppc32", Triple::ppc)
369 .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)
370 .Cases("powerpc64le", "ppc64le", Triple::ppc64le)
371 .Case("xscale", Triple::arm)
372 .Case("xscaleeb", Triple::armeb)
373 .Case("aarch64", Triple::aarch64)
374 .Case("aarch64_be", Triple::aarch64_be)
375 .Case("arm64", Triple::aarch64)
376 .Case("arm", Triple::arm)
377 .Case("armeb", Triple::armeb)
378 .Case("thumb", Triple::thumb)
379 .Case("thumbeb", Triple::thumbeb)
380 .Case("avr", Triple::avr)
381 .Case("msp430", Triple::msp430)
382 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
383 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
384 .Cases("mips64", "mips64eb", Triple::mips64)
385 .Case("mips64el", Triple::mips64el)
386 .Case("r600", Triple::r600)
387 .Case("amdgcn", Triple::amdgcn)
388 .Case("riscv32", Triple::riscv32)
389 .Case("riscv64", Triple::riscv64)
390 .Case("hexagon", Triple::hexagon)
391 .Cases("s390x", "systemz", Triple::systemz)
392 .Case("sparc", Triple::sparc)
393 .Case("sparcel", Triple::sparcel)
394 .Cases("sparcv9", "sparc64", Triple::sparcv9)
395 .Case("tce", Triple::tce)
396 .Case("tcele", Triple::tcele)
397 .Case("xcore", Triple::xcore)
398 .Case("nvptx", Triple::nvptx)
399 .Case("nvptx64", Triple::nvptx64)
400 .Case("le32", Triple::le32)
401 .Case("le64", Triple::le64)
402 .Case("amdil", Triple::amdil)
403 .Case("amdil64", Triple::amdil64)
404 .Case("hsail", Triple::hsail)
405 .Case("hsail64", Triple::hsail64)
406 .Case("spir", Triple::spir)
407 .Case("spir64", Triple::spir64)
408 .StartsWith("kalimba", Triple::kalimba)
409 .Case("lanai", Triple::lanai)
410 .Case("shave", Triple::shave)
411 .Case("wasm32", Triple::wasm32)
412 .Case("wasm64", Triple::wasm64)
413 .Case("renderscript32", Triple::renderscript32)
414 .Case("renderscript64", Triple::renderscript64)
415 .Default(Triple::UnknownArch);
417 // Some architectures require special parsing logic just to compute the
419 if (AT == Triple::UnknownArch) {
420 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
421 ArchName.startswith("aarch64"))
422 return parseARMArch(ArchName);
423 if (ArchName.startswith("bpf"))
424 return parseBPFArch(ArchName);
430 static Triple::VendorType parseVendor(StringRef VendorName) {
431 return StringSwitch<Triple::VendorType>(VendorName)
432 .Case("apple", Triple::Apple)
433 .Case("pc", Triple::PC)
434 .Case("scei", Triple::SCEI)
435 .Case("bgp", Triple::BGP)
436 .Case("bgq", Triple::BGQ)
437 .Case("fsl", Triple::Freescale)
438 .Case("ibm", Triple::IBM)
439 .Case("img", Triple::ImaginationTechnologies)
440 .Case("mti", Triple::MipsTechnologies)
441 .Case("nvidia", Triple::NVIDIA)
442 .Case("csr", Triple::CSR)
443 .Case("myriad", Triple::Myriad)
444 .Case("amd", Triple::AMD)
445 .Case("mesa", Triple::Mesa)
446 .Default(Triple::UnknownVendor);
449 static Triple::OSType parseOS(StringRef OSName) {
450 return StringSwitch<Triple::OSType>(OSName)
451 .StartsWith("cloudabi", Triple::CloudABI)
452 .StartsWith("darwin", Triple::Darwin)
453 .StartsWith("dragonfly", Triple::DragonFly)
454 .StartsWith("freebsd", Triple::FreeBSD)
455 .StartsWith("fuchsia", Triple::Fuchsia)
456 .StartsWith("ios", Triple::IOS)
457 .StartsWith("kfreebsd", Triple::KFreeBSD)
458 .StartsWith("linux", Triple::Linux)
459 .StartsWith("lv2", Triple::Lv2)
460 .StartsWith("macosx", Triple::MacOSX)
461 .StartsWith("netbsd", Triple::NetBSD)
462 .StartsWith("openbsd", Triple::OpenBSD)
463 .StartsWith("solaris", Triple::Solaris)
464 .StartsWith("win32", Triple::Win32)
465 .StartsWith("windows", Triple::Win32)
466 .StartsWith("haiku", Triple::Haiku)
467 .StartsWith("minix", Triple::Minix)
468 .StartsWith("rtems", Triple::RTEMS)
469 .StartsWith("nacl", Triple::NaCl)
470 .StartsWith("cnk", Triple::CNK)
471 .StartsWith("bitrig", Triple::Bitrig)
472 .StartsWith("aix", Triple::AIX)
473 .StartsWith("cuda", Triple::CUDA)
474 .StartsWith("nvcl", Triple::NVCL)
475 .StartsWith("amdhsa", Triple::AMDHSA)
476 .StartsWith("ps4", Triple::PS4)
477 .StartsWith("elfiamcu", Triple::ELFIAMCU)
478 .StartsWith("tvos", Triple::TvOS)
479 .StartsWith("watchos", Triple::WatchOS)
480 .StartsWith("mesa3d", Triple::Mesa3D)
481 .StartsWith("contiki", Triple::Contiki)
482 .Default(Triple::UnknownOS);
485 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
486 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
487 .StartsWith("eabihf", Triple::EABIHF)
488 .StartsWith("eabi", Triple::EABI)
489 .StartsWith("gnuabi64", Triple::GNUABI64)
490 .StartsWith("gnueabihf", Triple::GNUEABIHF)
491 .StartsWith("gnueabi", Triple::GNUEABI)
492 .StartsWith("gnux32", Triple::GNUX32)
493 .StartsWith("code16", Triple::CODE16)
494 .StartsWith("gnu", Triple::GNU)
495 .StartsWith("android", Triple::Android)
496 .StartsWith("musleabihf", Triple::MuslEABIHF)
497 .StartsWith("musleabi", Triple::MuslEABI)
498 .StartsWith("musl", Triple::Musl)
499 .StartsWith("msvc", Triple::MSVC)
500 .StartsWith("itanium", Triple::Itanium)
501 .StartsWith("cygnus", Triple::Cygnus)
502 .StartsWith("amdopencl", Triple::AMDOpenCL)
503 .StartsWith("coreclr", Triple::CoreCLR)
504 .StartsWith("opencl", Triple::OpenCL)
505 .Default(Triple::UnknownEnvironment);
508 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
509 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
510 .EndsWith("coff", Triple::COFF)
511 .EndsWith("elf", Triple::ELF)
512 .EndsWith("macho", Triple::MachO)
513 .Default(Triple::UnknownObjectFormat);
516 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
517 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
519 // For now, this is the small part. Early return.
520 if (ARMSubArch.empty())
521 return StringSwitch<Triple::SubArchType>(SubArchName)
522 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
523 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
524 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
525 .Default(Triple::NoSubArch);
528 switch(ARM::parseArch(ARMSubArch)) {
530 return Triple::NoSubArch;
532 return Triple::ARMSubArch_v4t;
534 return Triple::ARMSubArch_v5;
535 case ARM::AK_ARMV5TE:
537 case ARM::AK_IWMMXT2:
539 case ARM::AK_ARMV5TEJ:
540 return Triple::ARMSubArch_v5te;
542 return Triple::ARMSubArch_v6;
544 case ARM::AK_ARMV6KZ:
545 return Triple::ARMSubArch_v6k;
546 case ARM::AK_ARMV6T2:
547 return Triple::ARMSubArch_v6t2;
549 return Triple::ARMSubArch_v6m;
552 return Triple::ARMSubArch_v7;
554 return Triple::ARMSubArch_v7k;
556 return Triple::ARMSubArch_v7m;
558 return Triple::ARMSubArch_v7s;
559 case ARM::AK_ARMV7EM:
560 return Triple::ARMSubArch_v7em;
562 return Triple::ARMSubArch_v8;
563 case ARM::AK_ARMV8_1A:
564 return Triple::ARMSubArch_v8_1a;
565 case ARM::AK_ARMV8_2A:
566 return Triple::ARMSubArch_v8_2a;
568 return Triple::ARMSubArch_v8r;
569 case ARM::AK_ARMV8MBaseline:
570 return Triple::ARMSubArch_v8m_baseline;
571 case ARM::AK_ARMV8MMainline:
572 return Triple::ARMSubArch_v8m_mainline;
574 return Triple::NoSubArch;
578 static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
580 case Triple::UnknownObjectFormat: return "";
581 case Triple::COFF: return "coff";
582 case Triple::ELF: return "elf";
583 case Triple::MachO: return "macho";
585 llvm_unreachable("unknown object format type");
588 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
589 switch (T.getArch()) {
590 case Triple::UnknownArch:
591 case Triple::aarch64:
597 return Triple::MachO;
598 else if (T.isOSWindows())
602 case Triple::aarch64_be:
605 case Triple::amdil64:
610 case Triple::hexagon:
613 case Triple::hsail64:
614 case Triple::kalimba:
619 case Triple::mips64el:
623 case Triple::nvptx64:
624 case Triple::ppc64le:
626 case Triple::renderscript32:
627 case Triple::renderscript64:
628 case Triple::riscv32:
629 case Triple::riscv64:
632 case Triple::sparcel:
633 case Triple::sparcv9:
636 case Triple::systemz:
639 case Triple::thumbeb:
648 return Triple::MachO;
651 llvm_unreachable("unknown architecture");
654 /// \brief Construct a triple from the string representation provided.
656 /// This stores the string representation and parses the various pieces into
658 Triple::Triple(const Twine &Str)
659 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
660 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
661 ObjectFormat(UnknownObjectFormat) {
662 // Do minimal parsing by hand here.
663 SmallVector<StringRef, 4> Components;
664 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
665 if (Components.size() > 0) {
666 Arch = parseArch(Components[0]);
667 SubArch = parseSubArch(Components[0]);
668 if (Components.size() > 1) {
669 Vendor = parseVendor(Components[1]);
670 if (Components.size() > 2) {
671 OS = parseOS(Components[2]);
672 if (Components.size() > 3) {
673 Environment = parseEnvironment(Components[3]);
674 ObjectFormat = parseFormat(Components[3]);
679 if (ObjectFormat == UnknownObjectFormat)
680 ObjectFormat = getDefaultFormat(*this);
683 /// \brief Construct a triple from string representations of the architecture,
686 /// This joins each argument into a canonical string representation and parses
687 /// them into enum members. It leaves the environment unknown and omits it from
688 /// the string representation.
689 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
690 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
691 Arch(parseArch(ArchStr.str())),
692 SubArch(parseSubArch(ArchStr.str())),
693 Vendor(parseVendor(VendorStr.str())),
694 OS(parseOS(OSStr.str())),
695 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
696 ObjectFormat = getDefaultFormat(*this);
699 /// \brief Construct a triple from string representations of the architecture,
700 /// vendor, OS, and environment.
702 /// This joins each argument into a canonical string representation and parses
703 /// them into enum members.
704 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
705 const Twine &EnvironmentStr)
706 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
707 EnvironmentStr).str()),
708 Arch(parseArch(ArchStr.str())),
709 SubArch(parseSubArch(ArchStr.str())),
710 Vendor(parseVendor(VendorStr.str())),
711 OS(parseOS(OSStr.str())),
712 Environment(parseEnvironment(EnvironmentStr.str())),
713 ObjectFormat(parseFormat(EnvironmentStr.str())) {
714 if (ObjectFormat == Triple::UnknownObjectFormat)
715 ObjectFormat = getDefaultFormat(*this);
718 std::string Triple::normalize(StringRef Str) {
719 bool IsMinGW32 = false;
720 bool IsCygwin = false;
722 // Parse into components.
723 SmallVector<StringRef, 4> Components;
724 Str.split(Components, '-');
726 // If the first component corresponds to a known architecture, preferentially
727 // use it for the architecture. If the second component corresponds to a
728 // known vendor, preferentially use it for the vendor, etc. This avoids silly
729 // component movement when a component parses as (eg) both a valid arch and a
731 ArchType Arch = UnknownArch;
732 if (Components.size() > 0)
733 Arch = parseArch(Components[0]);
734 VendorType Vendor = UnknownVendor;
735 if (Components.size() > 1)
736 Vendor = parseVendor(Components[1]);
737 OSType OS = UnknownOS;
738 if (Components.size() > 2) {
739 OS = parseOS(Components[2]);
740 IsCygwin = Components[2].startswith("cygwin");
741 IsMinGW32 = Components[2].startswith("mingw");
743 EnvironmentType Environment = UnknownEnvironment;
744 if (Components.size() > 3)
745 Environment = parseEnvironment(Components[3]);
746 ObjectFormatType ObjectFormat = UnknownObjectFormat;
747 if (Components.size() > 4)
748 ObjectFormat = parseFormat(Components[4]);
750 // Note which components are already in their final position. These will not
753 Found[0] = Arch != UnknownArch;
754 Found[1] = Vendor != UnknownVendor;
755 Found[2] = OS != UnknownOS;
756 Found[3] = Environment != UnknownEnvironment;
758 // If they are not there already, permute the components into their canonical
759 // positions by seeing if they parse as a valid architecture, and if so moving
760 // the component to the architecture position etc.
761 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
763 continue; // Already in the canonical position.
765 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
766 // Do not reparse any components that already matched.
767 if (Idx < array_lengthof(Found) && Found[Idx])
770 // Does this component parse as valid for the target position?
772 StringRef Comp = Components[Idx];
774 default: llvm_unreachable("unexpected component type!");
776 Arch = parseArch(Comp);
777 Valid = Arch != UnknownArch;
780 Vendor = parseVendor(Comp);
781 Valid = Vendor != UnknownVendor;
785 IsCygwin = Comp.startswith("cygwin");
786 IsMinGW32 = Comp.startswith("mingw");
787 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
790 Environment = parseEnvironment(Comp);
791 Valid = Environment != UnknownEnvironment;
793 ObjectFormat = parseFormat(Comp);
794 Valid = ObjectFormat != UnknownObjectFormat;
799 continue; // Nope, try the next component.
801 // Move the component to the target position, pushing any non-fixed
802 // components that are in the way to the right. This tends to give
803 // good results in the common cases of a forgotten vendor component
804 // or a wrongly positioned environment.
806 // Insert left, pushing the existing components to the right. For
807 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
808 StringRef CurrentComponent(""); // The empty component.
809 // Replace the component we are moving with an empty component.
810 std::swap(CurrentComponent, Components[Idx]);
811 // Insert the component being moved at Pos, displacing any existing
812 // components to the right.
813 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
814 // Skip over any fixed components.
815 while (i < array_lengthof(Found) && Found[i])
817 // Place the component at the new position, getting the component
818 // that was at this position - it will be moved right.
819 std::swap(CurrentComponent, Components[i]);
821 } else if (Pos > Idx) {
822 // Push right by inserting empty components until the component at Idx
823 // reaches the target position Pos. For example, pc-a -> -pc-a when
824 // moving pc to the second position.
826 // Insert one empty component at Idx.
827 StringRef CurrentComponent(""); // The empty component.
828 for (unsigned i = Idx; i < Components.size();) {
829 // Place the component at the new position, getting the component
830 // that was at this position - it will be moved right.
831 std::swap(CurrentComponent, Components[i]);
832 // If it was placed on top of an empty component then we are done.
833 if (CurrentComponent.empty())
835 // Advance to the next component, skipping any fixed components.
836 while (++i < array_lengthof(Found) && Found[i])
839 // The last component was pushed off the end - append it.
840 if (!CurrentComponent.empty())
841 Components.push_back(CurrentComponent);
843 // Advance Idx to the component's new position.
844 while (++Idx < array_lengthof(Found) && Found[Idx])
846 } while (Idx < Pos); // Add more until the final position is reached.
848 assert(Pos < Components.size() && Components[Pos] == Comp &&
849 "Component moved wrong!");
855 // Special case logic goes here. At this point Arch, Vendor and OS have the
856 // correct values for the computed components.
857 std::string NormalizedEnvironment;
858 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
859 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
860 if (AndroidVersion.empty()) {
861 Components[3] = "android";
863 NormalizedEnvironment = Twine("android", AndroidVersion).str();
864 Components[3] = NormalizedEnvironment;
868 if (OS == Triple::Win32) {
869 Components.resize(4);
870 Components[2] = "windows";
871 if (Environment == UnknownEnvironment) {
872 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
873 Components[3] = "msvc";
875 Components[3] = getObjectFormatTypeName(ObjectFormat);
877 } else if (IsMinGW32) {
878 Components.resize(4);
879 Components[2] = "windows";
880 Components[3] = "gnu";
881 } else if (IsCygwin) {
882 Components.resize(4);
883 Components[2] = "windows";
884 Components[3] = "cygnus";
886 if (IsMinGW32 || IsCygwin ||
887 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
888 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
889 Components.resize(5);
890 Components[4] = getObjectFormatTypeName(ObjectFormat);
894 // Stick the corrected components back together to form the normalized string.
895 std::string Normalized;
896 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
897 if (i) Normalized += '-';
898 Normalized += Components[i];
903 StringRef Triple::getArchName() const {
904 return StringRef(Data).split('-').first; // Isolate first component
907 StringRef Triple::getVendorName() const {
908 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
909 return Tmp.split('-').first; // Isolate second component
912 StringRef Triple::getOSName() const {
913 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
914 Tmp = Tmp.split('-').second; // Strip second component
915 return Tmp.split('-').first; // Isolate third component
918 StringRef Triple::getEnvironmentName() const {
919 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
920 Tmp = Tmp.split('-').second; // Strip second component
921 return Tmp.split('-').second; // Strip third component
924 StringRef Triple::getOSAndEnvironmentName() const {
925 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
926 return Tmp.split('-').second; // Strip second component
929 static unsigned EatNumber(StringRef &Str) {
930 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
934 // Consume the leading digit.
935 Result = Result*10 + (Str[0] - '0');
939 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
944 static void parseVersionFromName(StringRef Name, unsigned &Major,
945 unsigned &Minor, unsigned &Micro) {
946 // Any unset version defaults to 0.
947 Major = Minor = Micro = 0;
949 // Parse up to three components.
950 unsigned *Components[3] = {&Major, &Minor, &Micro};
951 for (unsigned i = 0; i != 3; ++i) {
952 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
955 // Consume the leading number.
956 *Components[i] = EatNumber(Name);
958 // Consume the separator, if present.
959 if (Name.startswith("."))
960 Name = Name.substr(1);
964 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
965 unsigned &Micro) const {
966 StringRef EnvironmentName = getEnvironmentName();
967 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
968 if (EnvironmentName.startswith(EnvironmentTypeName))
969 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
971 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
974 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
975 unsigned &Micro) const {
976 StringRef OSName = getOSName();
977 // Assume that the OS portion of the triple starts with the canonical name.
978 StringRef OSTypeName = getOSTypeName(getOS());
979 if (OSName.startswith(OSTypeName))
980 OSName = OSName.substr(OSTypeName.size());
982 parseVersionFromName(OSName, Major, Minor, Micro);
985 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
986 unsigned &Micro) const {
987 getOSVersion(Major, Minor, Micro);
990 default: llvm_unreachable("unexpected OS for Darwin triple");
992 // Default to darwin8, i.e., MacOSX 10.4.
995 // Darwin version numbers are skewed from OS X versions.
1014 // Ignore the version from the triple. This is only handled because the
1015 // the clang driver combines OS X and IOS support into a common Darwin
1016 // toolchain that wants to know the OS X version number even when targeting
1026 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
1027 unsigned &Micro) const {
1029 default: llvm_unreachable("unexpected OS for Darwin triple");
1032 // Ignore the version from the triple. This is only handled because the
1033 // the clang driver combines OS X and IOS support into a common Darwin
1034 // toolchain that wants to know the iOS version number even when targeting
1042 getOSVersion(Major, Minor, Micro);
1043 // Default to 5.0 (or 7.0 for arm64).
1045 Major = (getArch() == aarch64) ? 7 : 5;
1048 llvm_unreachable("conflicting triple info");
1052 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
1053 unsigned &Micro) const {
1055 default: llvm_unreachable("unexpected OS for Darwin triple");
1058 // Ignore the version from the triple. This is only handled because the
1059 // the clang driver combines OS X and IOS support into a common Darwin
1060 // toolchain that wants to know the iOS version number even when targeting
1067 getOSVersion(Major, Minor, Micro);
1072 llvm_unreachable("conflicting triple info");
1076 void Triple::setTriple(const Twine &Str) {
1077 *this = Triple(Str);
1080 void Triple::setArch(ArchType Kind) {
1081 setArchName(getArchTypeName(Kind));
1084 void Triple::setVendor(VendorType Kind) {
1085 setVendorName(getVendorTypeName(Kind));
1088 void Triple::setOS(OSType Kind) {
1089 setOSName(getOSTypeName(Kind));
1092 void Triple::setEnvironment(EnvironmentType Kind) {
1093 if (ObjectFormat == getDefaultFormat(*this))
1094 return setEnvironmentName(getEnvironmentTypeName(Kind));
1096 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1097 getObjectFormatTypeName(ObjectFormat)).str());
1100 void Triple::setObjectFormat(ObjectFormatType Kind) {
1101 if (Environment == UnknownEnvironment)
1102 return setEnvironmentName(getObjectFormatTypeName(Kind));
1104 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1105 getObjectFormatTypeName(Kind)).str());
1108 void Triple::setArchName(StringRef Str) {
1109 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1110 SmallString<64> Triple;
1113 Triple += getVendorName();
1115 Triple += getOSAndEnvironmentName();
1119 void Triple::setVendorName(StringRef Str) {
1120 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1123 void Triple::setOSName(StringRef Str) {
1124 if (hasEnvironment())
1125 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1126 "-" + getEnvironmentName());
1128 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1131 void Triple::setEnvironmentName(StringRef Str) {
1132 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1136 void Triple::setOSAndEnvironmentName(StringRef Str) {
1137 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1140 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1142 case llvm::Triple::UnknownArch:
1145 case llvm::Triple::avr:
1146 case llvm::Triple::msp430:
1149 case llvm::Triple::arm:
1150 case llvm::Triple::armeb:
1151 case llvm::Triple::hexagon:
1152 case llvm::Triple::le32:
1153 case llvm::Triple::mips:
1154 case llvm::Triple::mipsel:
1155 case llvm::Triple::nvptx:
1156 case llvm::Triple::ppc:
1157 case llvm::Triple::r600:
1158 case llvm::Triple::riscv32:
1159 case llvm::Triple::sparc:
1160 case llvm::Triple::sparcel:
1161 case llvm::Triple::tce:
1162 case llvm::Triple::tcele:
1163 case llvm::Triple::thumb:
1164 case llvm::Triple::thumbeb:
1165 case llvm::Triple::x86:
1166 case llvm::Triple::xcore:
1167 case llvm::Triple::amdil:
1168 case llvm::Triple::hsail:
1169 case llvm::Triple::spir:
1170 case llvm::Triple::kalimba:
1171 case llvm::Triple::lanai:
1172 case llvm::Triple::shave:
1173 case llvm::Triple::wasm32:
1174 case llvm::Triple::renderscript32:
1177 case llvm::Triple::aarch64:
1178 case llvm::Triple::aarch64_be:
1179 case llvm::Triple::amdgcn:
1180 case llvm::Triple::bpfel:
1181 case llvm::Triple::bpfeb:
1182 case llvm::Triple::le64:
1183 case llvm::Triple::mips64:
1184 case llvm::Triple::mips64el:
1185 case llvm::Triple::nvptx64:
1186 case llvm::Triple::ppc64:
1187 case llvm::Triple::ppc64le:
1188 case llvm::Triple::riscv64:
1189 case llvm::Triple::sparcv9:
1190 case llvm::Triple::systemz:
1191 case llvm::Triple::x86_64:
1192 case llvm::Triple::amdil64:
1193 case llvm::Triple::hsail64:
1194 case llvm::Triple::spir64:
1195 case llvm::Triple::wasm64:
1196 case llvm::Triple::renderscript64:
1199 llvm_unreachable("Invalid architecture value");
1202 bool Triple::isArch64Bit() const {
1203 return getArchPointerBitWidth(getArch()) == 64;
1206 bool Triple::isArch32Bit() const {
1207 return getArchPointerBitWidth(getArch()) == 32;
1210 bool Triple::isArch16Bit() const {
1211 return getArchPointerBitWidth(getArch()) == 16;
1214 Triple Triple::get32BitArchVariant() const {
1216 switch (getArch()) {
1217 case Triple::UnknownArch:
1218 case Triple::amdgcn:
1222 case Triple::msp430:
1223 case Triple::systemz:
1224 case Triple::ppc64le:
1225 T.setArch(UnknownArch);
1233 case Triple::hexagon:
1234 case Triple::kalimba:
1237 case Triple::mipsel:
1241 case Triple::riscv32:
1243 case Triple::sparcel:
1247 case Triple::thumbeb:
1252 case Triple::wasm32:
1253 case Triple::renderscript32:
1257 case Triple::aarch64: T.setArch(Triple::arm); break;
1258 case Triple::aarch64_be: T.setArch(Triple::armeb); break;
1259 case Triple::le64: T.setArch(Triple::le32); break;
1260 case Triple::mips64: T.setArch(Triple::mips); break;
1261 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1262 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1263 case Triple::ppc64: T.setArch(Triple::ppc); break;
1264 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1265 case Triple::riscv64: T.setArch(Triple::riscv32); break;
1266 case Triple::x86_64: T.setArch(Triple::x86); break;
1267 case Triple::amdil64: T.setArch(Triple::amdil); break;
1268 case Triple::hsail64: T.setArch(Triple::hsail); break;
1269 case Triple::spir64: T.setArch(Triple::spir); break;
1270 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1271 case Triple::renderscript64: T.setArch(Triple::renderscript32); break;
1276 Triple Triple::get64BitArchVariant() const {
1278 switch (getArch()) {
1279 case Triple::UnknownArch:
1281 case Triple::hexagon:
1282 case Triple::kalimba:
1284 case Triple::msp430:
1289 case Triple::sparcel:
1291 T.setArch(UnknownArch);
1294 case Triple::aarch64:
1295 case Triple::aarch64_be:
1299 case Triple::amdil64:
1300 case Triple::amdgcn:
1301 case Triple::hsail64:
1302 case Triple::spir64:
1303 case Triple::mips64:
1304 case Triple::mips64el:
1305 case Triple::nvptx64:
1307 case Triple::ppc64le:
1308 case Triple::riscv64:
1309 case Triple::sparcv9:
1310 case Triple::systemz:
1311 case Triple::x86_64:
1312 case Triple::wasm64:
1313 case Triple::renderscript64:
1317 case Triple::arm: T.setArch(Triple::aarch64); break;
1318 case Triple::armeb: T.setArch(Triple::aarch64_be); break;
1319 case Triple::le32: T.setArch(Triple::le64); break;
1320 case Triple::mips: T.setArch(Triple::mips64); break;
1321 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1322 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1323 case Triple::ppc: T.setArch(Triple::ppc64); break;
1324 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1325 case Triple::riscv32: T.setArch(Triple::riscv64); break;
1326 case Triple::x86: T.setArch(Triple::x86_64); break;
1327 case Triple::amdil: T.setArch(Triple::amdil64); break;
1328 case Triple::hsail: T.setArch(Triple::hsail64); break;
1329 case Triple::spir: T.setArch(Triple::spir64); break;
1330 case Triple::thumb: T.setArch(Triple::aarch64); break;
1331 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break;
1332 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1333 case Triple::renderscript32: T.setArch(Triple::renderscript64); break;
1338 Triple Triple::getBigEndianArchVariant() const {
1340 // Already big endian.
1341 if (!isLittleEndian())
1343 switch (getArch()) {
1344 case Triple::UnknownArch:
1345 case Triple::amdgcn:
1346 case Triple::amdil64:
1349 case Triple::hexagon:
1350 case Triple::hsail64:
1352 case Triple::kalimba:
1355 case Triple::msp430:
1356 case Triple::nvptx64:
1359 case Triple::riscv32:
1360 case Triple::riscv64:
1362 case Triple::spir64:
1364 case Triple::wasm32:
1365 case Triple::wasm64:
1367 case Triple::x86_64:
1369 case Triple::renderscript32:
1370 case Triple::renderscript64:
1372 // ARM is intentionally unsupported here, changing the architecture would
1373 // drop any arch suffixes.
1376 T.setArch(UnknownArch);
1379 case Triple::tcele: T.setArch(Triple::tce); break;
1380 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1381 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1382 case Triple::mips64el:T.setArch(Triple::mips64); break;
1383 case Triple::mipsel: T.setArch(Triple::mips); break;
1384 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1385 case Triple::sparcel: T.setArch(Triple::sparc); break;
1387 llvm_unreachable("getBigEndianArchVariant: unknown triple.");
1392 Triple Triple::getLittleEndianArchVariant() const {
1394 if (isLittleEndian())
1397 switch (getArch()) {
1398 case Triple::UnknownArch:
1401 case Triple::sparcv9:
1402 case Triple::systemz:
1404 // ARM is intentionally unsupported here, changing the architecture would
1405 // drop any arch suffixes.
1407 case Triple::thumbeb:
1408 T.setArch(UnknownArch);
1411 case Triple::tce: T.setArch(Triple::tcele); break;
1412 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1413 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1414 case Triple::mips64: T.setArch(Triple::mips64el); break;
1415 case Triple::mips: T.setArch(Triple::mipsel); break;
1416 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1417 case Triple::sparc: T.setArch(Triple::sparcel); break;
1419 llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
1424 bool Triple::isLittleEndian() const {
1425 switch (getArch()) {
1426 case Triple::aarch64:
1427 case Triple::amdgcn:
1428 case Triple::amdil64:
1433 case Triple::hexagon:
1434 case Triple::hsail64:
1436 case Triple::kalimba:
1439 case Triple::mips64el:
1440 case Triple::mipsel:
1441 case Triple::msp430:
1442 case Triple::nvptx64:
1444 case Triple::ppc64le:
1446 case Triple::riscv32:
1447 case Triple::riscv64:
1449 case Triple::sparcel:
1450 case Triple::spir64:
1453 case Triple::wasm32:
1454 case Triple::wasm64:
1456 case Triple::x86_64:
1459 case Triple::renderscript32:
1460 case Triple::renderscript64:
1467 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1469 MArch = getArchName();
1470 MArch = ARM::getCanonicalArchName(MArch);
1472 // Some defaults are forced.
1474 case llvm::Triple::FreeBSD:
1475 case llvm::Triple::NetBSD:
1476 if (!MArch.empty() && MArch == "v6")
1477 return "arm1176jzf-s";
1479 case llvm::Triple::Win32:
1480 // FIXME: this is invalid for WindowsCE
1482 case llvm::Triple::MacOSX:
1483 case llvm::Triple::IOS:
1484 case llvm::Triple::WatchOS:
1485 case llvm::Triple::TvOS:
1496 StringRef CPU = ARM::getDefaultCPU(MArch);
1500 // If no specific architecture version is requested, return the minimum CPU
1501 // required by the OS and environment.
1503 case llvm::Triple::NetBSD:
1504 switch (getEnvironment()) {
1505 case llvm::Triple::GNUEABIHF:
1506 case llvm::Triple::GNUEABI:
1507 case llvm::Triple::EABIHF:
1508 case llvm::Triple::EABI:
1509 return "arm926ej-s";
1513 case llvm::Triple::NaCl:
1516 switch (getEnvironment()) {
1517 case llvm::Triple::EABIHF:
1518 case llvm::Triple::GNUEABIHF:
1519 case llvm::Triple::MuslEABIHF:
1520 return "arm1176jzf-s";
1526 llvm_unreachable("invalid arch name");