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 const char *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 sparc: return "sparc";
43 case sparcv9: return "sparcv9";
44 case sparcel: return "sparcel";
45 case systemz: return "s390x";
46 case tce: return "tce";
47 case thumb: return "thumb";
48 case thumbeb: return "thumbeb";
49 case x86: return "i386";
50 case x86_64: return "x86_64";
51 case xcore: return "xcore";
52 case nvptx: return "nvptx";
53 case nvptx64: return "nvptx64";
54 case le32: return "le32";
55 case le64: return "le64";
56 case amdil: return "amdil";
57 case amdil64: return "amdil64";
58 case hsail: return "hsail";
59 case hsail64: return "hsail64";
60 case spir: return "spir";
61 case spir64: return "spir64";
62 case kalimba: return "kalimba";
63 case shave: return "shave";
64 case wasm32: return "wasm32";
65 case wasm64: return "wasm64";
68 llvm_unreachable("Invalid ArchType!");
71 const char *Triple::getArchTypePrefix(ArchType Kind) {
77 case aarch64_be: return "aarch64";
82 case thumbeb: return "arm";
84 case avr: return "avr";
88 case ppc: return "ppc";
93 case mips64el: return "mips";
95 case hexagon: return "hexagon";
98 case r600: return "amdgpu";
101 case bpfeb: return "bpf";
105 case sparc: return "sparc";
107 case systemz: return "s390";
110 case x86_64: return "x86";
112 case xcore: return "xcore";
114 case nvptx: return "nvptx";
115 case nvptx64: return "nvptx";
117 case le32: return "le32";
118 case le64: return "le64";
121 case amdil64: return "amdil";
124 case hsail64: return "hsail";
127 case spir64: return "spir";
128 case kalimba: return "kalimba";
129 case shave: return "shave";
131 case wasm64: return "wasm";
135 const char *Triple::getVendorTypeName(VendorType Kind) {
137 case UnknownVendor: return "unknown";
139 case Apple: return "apple";
140 case PC: return "pc";
141 case SCEI: return "scei";
142 case BGP: return "bgp";
143 case BGQ: return "bgq";
144 case Freescale: return "fsl";
145 case IBM: return "ibm";
146 case ImaginationTechnologies: return "img";
147 case MipsTechnologies: return "mti";
148 case NVIDIA: return "nvidia";
149 case CSR: return "csr";
150 case Myriad: return "myriad";
153 llvm_unreachable("Invalid VendorType!");
156 const char *Triple::getOSTypeName(OSType Kind) {
158 case UnknownOS: return "unknown";
160 case CloudABI: return "cloudabi";
161 case Darwin: return "darwin";
162 case DragonFly: return "dragonfly";
163 case FreeBSD: return "freebsd";
164 case IOS: return "ios";
165 case KFreeBSD: return "kfreebsd";
166 case Linux: return "linux";
167 case Lv2: return "lv2";
168 case MacOSX: return "macosx";
169 case NetBSD: return "netbsd";
170 case OpenBSD: return "openbsd";
171 case Solaris: return "solaris";
172 case Win32: return "windows";
173 case Haiku: return "haiku";
174 case Minix: return "minix";
175 case RTEMS: return "rtems";
176 case NaCl: return "nacl";
177 case CNK: return "cnk";
178 case Bitrig: return "bitrig";
179 case AIX: return "aix";
180 case CUDA: return "cuda";
181 case NVCL: return "nvcl";
182 case AMDHSA: return "amdhsa";
183 case PS4: return "ps4";
184 case ELFIAMCU: return "elfiamcu";
185 case TvOS: return "tvos";
186 case WatchOS: return "watchos";
189 llvm_unreachable("Invalid OSType");
192 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
194 case UnknownEnvironment: return "unknown";
195 case GNU: return "gnu";
196 case GNUEABIHF: return "gnueabihf";
197 case GNUEABI: return "gnueabi";
198 case GNUX32: return "gnux32";
199 case CODE16: return "code16";
200 case EABI: return "eabi";
201 case EABIHF: return "eabihf";
202 case Android: return "android";
203 case MSVC: return "msvc";
204 case Itanium: return "itanium";
205 case Cygnus: return "cygnus";
206 case AMDOpenCL: return "amdopencl";
207 case CoreCLR: return "coreclr";
210 llvm_unreachable("Invalid EnvironmentType!");
213 static Triple::ArchType parseBPFArch(StringRef ArchName) {
214 if (ArchName.equals("bpf")) {
215 if (sys::IsLittleEndianHost)
216 return Triple::bpfel;
218 return Triple::bpfeb;
219 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
220 return Triple::bpfeb;
221 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
222 return Triple::bpfel;
224 return Triple::UnknownArch;
228 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
229 Triple::ArchType BPFArch(parseBPFArch(Name));
230 return StringSwitch<Triple::ArchType>(Name)
231 .Case("aarch64", aarch64)
232 .Case("aarch64_be", aarch64_be)
233 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
235 .Case("armeb", armeb)
237 .StartsWith("bpf", BPFArch)
239 .Case("mipsel", mipsel)
240 .Case("mips64", mips64)
241 .Case("mips64el", mips64el)
242 .Case("msp430", msp430)
243 .Case("ppc64", ppc64)
246 .Case("ppc64le", ppc64le)
248 .Case("amdgcn", amdgcn)
249 .Case("hexagon", hexagon)
250 .Case("sparc", sparc)
251 .Case("sparcel", sparcel)
252 .Case("sparcv9", sparcv9)
253 .Case("systemz", systemz)
255 .Case("thumb", thumb)
256 .Case("thumbeb", thumbeb)
258 .Case("x86-64", x86_64)
259 .Case("xcore", xcore)
260 .Case("nvptx", nvptx)
261 .Case("nvptx64", nvptx64)
264 .Case("amdil", amdil)
265 .Case("amdil64", amdil64)
266 .Case("hsail", hsail)
267 .Case("hsail64", hsail64)
269 .Case("spir64", spir64)
270 .Case("kalimba", kalimba)
271 .Case("shave", shave)
272 .Case("wasm32", wasm32)
273 .Case("wasm64", wasm64)
274 .Default(UnknownArch);
277 static Triple::ArchType parseARMArch(StringRef ArchName) {
278 unsigned ISA = ARM::parseArchISA(ArchName);
279 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
281 Triple::ArchType arch = Triple::UnknownArch;
283 case ARM::EK_LITTLE: {
289 arch = Triple::thumb;
291 case ARM::IK_AARCH64:
292 arch = Triple::aarch64;
300 arch = Triple::armeb;
303 arch = Triple::thumbeb;
305 case ARM::IK_AARCH64:
306 arch = Triple::aarch64_be;
313 ArchName = ARM::getCanonicalArchName(ArchName);
314 if (ArchName.empty())
315 return Triple::UnknownArch;
317 // Thumb only exists in v4+
318 if (ISA == ARM::IK_THUMB &&
319 (ArchName.startswith("v2") || ArchName.startswith("v3")))
320 return Triple::UnknownArch;
322 // Thumb only for v6m
323 unsigned Profile = ARM::parseArchProfile(ArchName);
324 unsigned Version = ARM::parseArchVersion(ArchName);
325 if (Profile == ARM::PK_M && Version == 6) {
326 if (ENDIAN == ARM::EK_BIG)
327 return Triple::thumbeb;
329 return Triple::thumb;
335 static Triple::ArchType parseArch(StringRef ArchName) {
336 auto AT = StringSwitch<Triple::ArchType>(ArchName)
337 .Cases("i386", "i486", "i586", "i686", Triple::x86)
338 // FIXME: Do we need to support these?
339 .Cases("i786", "i886", "i986", Triple::x86)
340 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
341 .Case("powerpc", Triple::ppc)
342 .Cases("powerpc64", "ppu", Triple::ppc64)
343 .Case("powerpc64le", Triple::ppc64le)
344 .Case("xscale", Triple::arm)
345 .Case("xscaleeb", Triple::armeb)
346 .Case("aarch64", Triple::aarch64)
347 .Case("aarch64_be", Triple::aarch64_be)
348 .Case("arm64", Triple::aarch64)
349 .Case("arm", Triple::arm)
350 .Case("armeb", Triple::armeb)
351 .Case("thumb", Triple::thumb)
352 .Case("thumbeb", Triple::thumbeb)
353 .Case("avr", Triple::avr)
354 .Case("msp430", Triple::msp430)
355 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
356 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
357 .Cases("mips64", "mips64eb", Triple::mips64)
358 .Case("mips64el", Triple::mips64el)
359 .Case("r600", Triple::r600)
360 .Case("amdgcn", Triple::amdgcn)
361 .Case("hexagon", Triple::hexagon)
362 .Case("s390x", Triple::systemz)
363 .Case("sparc", Triple::sparc)
364 .Case("sparcel", Triple::sparcel)
365 .Cases("sparcv9", "sparc64", Triple::sparcv9)
366 .Case("tce", Triple::tce)
367 .Case("xcore", Triple::xcore)
368 .Case("nvptx", Triple::nvptx)
369 .Case("nvptx64", Triple::nvptx64)
370 .Case("le32", Triple::le32)
371 .Case("le64", Triple::le64)
372 .Case("amdil", Triple::amdil)
373 .Case("amdil64", Triple::amdil64)
374 .Case("hsail", Triple::hsail)
375 .Case("hsail64", Triple::hsail64)
376 .Case("spir", Triple::spir)
377 .Case("spir64", Triple::spir64)
378 .StartsWith("kalimba", Triple::kalimba)
379 .Case("shave", Triple::shave)
380 .Case("wasm32", Triple::wasm32)
381 .Case("wasm64", Triple::wasm64)
382 .Default(Triple::UnknownArch);
384 // Some architectures require special parsing logic just to compute the
386 if (AT == Triple::UnknownArch) {
387 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
388 ArchName.startswith("aarch64"))
389 return parseARMArch(ArchName);
390 if (ArchName.startswith("bpf"))
391 return parseBPFArch(ArchName);
397 static Triple::VendorType parseVendor(StringRef VendorName) {
398 return StringSwitch<Triple::VendorType>(VendorName)
399 .Case("apple", Triple::Apple)
400 .Case("pc", Triple::PC)
401 .Case("scei", Triple::SCEI)
402 .Case("bgp", Triple::BGP)
403 .Case("bgq", Triple::BGQ)
404 .Case("fsl", Triple::Freescale)
405 .Case("ibm", Triple::IBM)
406 .Case("img", Triple::ImaginationTechnologies)
407 .Case("mti", Triple::MipsTechnologies)
408 .Case("nvidia", Triple::NVIDIA)
409 .Case("csr", Triple::CSR)
410 .Case("myriad", Triple::Myriad)
411 .Default(Triple::UnknownVendor);
414 static Triple::OSType parseOS(StringRef OSName) {
415 return StringSwitch<Triple::OSType>(OSName)
416 .StartsWith("cloudabi", Triple::CloudABI)
417 .StartsWith("darwin", Triple::Darwin)
418 .StartsWith("dragonfly", Triple::DragonFly)
419 .StartsWith("freebsd", Triple::FreeBSD)
420 .StartsWith("ios", Triple::IOS)
421 .StartsWith("kfreebsd", Triple::KFreeBSD)
422 .StartsWith("linux", Triple::Linux)
423 .StartsWith("lv2", Triple::Lv2)
424 .StartsWith("macosx", Triple::MacOSX)
425 .StartsWith("netbsd", Triple::NetBSD)
426 .StartsWith("openbsd", Triple::OpenBSD)
427 .StartsWith("solaris", Triple::Solaris)
428 .StartsWith("win32", Triple::Win32)
429 .StartsWith("windows", Triple::Win32)
430 .StartsWith("haiku", Triple::Haiku)
431 .StartsWith("minix", Triple::Minix)
432 .StartsWith("rtems", Triple::RTEMS)
433 .StartsWith("nacl", Triple::NaCl)
434 .StartsWith("cnk", Triple::CNK)
435 .StartsWith("bitrig", Triple::Bitrig)
436 .StartsWith("aix", Triple::AIX)
437 .StartsWith("cuda", Triple::CUDA)
438 .StartsWith("nvcl", Triple::NVCL)
439 .StartsWith("amdhsa", Triple::AMDHSA)
440 .StartsWith("ps4", Triple::PS4)
441 .StartsWith("elfiamcu", Triple::ELFIAMCU)
442 .StartsWith("tvos", Triple::TvOS)
443 .StartsWith("watchos", Triple::WatchOS)
444 .Default(Triple::UnknownOS);
447 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
448 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
449 .StartsWith("eabihf", Triple::EABIHF)
450 .StartsWith("eabi", Triple::EABI)
451 .StartsWith("gnueabihf", Triple::GNUEABIHF)
452 .StartsWith("gnueabi", Triple::GNUEABI)
453 .StartsWith("gnux32", Triple::GNUX32)
454 .StartsWith("code16", Triple::CODE16)
455 .StartsWith("gnu", Triple::GNU)
456 .StartsWith("android", Triple::Android)
457 .StartsWith("msvc", Triple::MSVC)
458 .StartsWith("itanium", Triple::Itanium)
459 .StartsWith("cygnus", Triple::Cygnus)
460 .StartsWith("amdopencl", Triple::AMDOpenCL)
461 .StartsWith("coreclr", Triple::CoreCLR)
462 .Default(Triple::UnknownEnvironment);
465 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
466 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
467 .EndsWith("coff", Triple::COFF)
468 .EndsWith("elf", Triple::ELF)
469 .EndsWith("macho", Triple::MachO)
470 .Default(Triple::UnknownObjectFormat);
473 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
474 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
476 // For now, this is the small part. Early return.
477 if (ARMSubArch.empty())
478 return StringSwitch<Triple::SubArchType>(SubArchName)
479 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
480 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
481 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
482 .Default(Triple::NoSubArch);
485 switch(ARM::parseArch(ARMSubArch)) {
487 return Triple::NoSubArch;
489 return Triple::ARMSubArch_v4t;
491 return Triple::ARMSubArch_v5;
492 case ARM::AK_ARMV5TE:
494 case ARM::AK_IWMMXT2:
496 case ARM::AK_ARMV5TEJ:
497 return Triple::ARMSubArch_v5te;
499 return Triple::ARMSubArch_v6;
501 case ARM::AK_ARMV6KZ:
502 return Triple::ARMSubArch_v6k;
503 case ARM::AK_ARMV6T2:
504 return Triple::ARMSubArch_v6t2;
506 return Triple::ARMSubArch_v6m;
509 return Triple::ARMSubArch_v7;
511 return Triple::ARMSubArch_v7k;
513 return Triple::ARMSubArch_v7m;
515 return Triple::ARMSubArch_v7s;
516 case ARM::AK_ARMV7EM:
517 return Triple::ARMSubArch_v7em;
519 return Triple::ARMSubArch_v8;
520 case ARM::AK_ARMV8_1A:
521 return Triple::ARMSubArch_v8_1a;
522 case ARM::AK_ARMV8_2A:
523 return Triple::ARMSubArch_v8_2a;
525 return Triple::NoSubArch;
529 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
531 case Triple::UnknownObjectFormat: return "";
532 case Triple::COFF: return "coff";
533 case Triple::ELF: return "elf";
534 case Triple::MachO: return "macho";
536 llvm_unreachable("unknown object format type");
539 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
540 switch (T.getArch()) {
541 case Triple::UnknownArch:
542 case Triple::aarch64:
548 return Triple::MachO;
549 else if (T.isOSWindows())
553 case Triple::aarch64_be:
556 case Triple::amdil64:
561 case Triple::hexagon:
563 case Triple::hsail64:
564 case Triple::kalimba:
569 case Triple::mips64el:
573 case Triple::nvptx64:
574 case Triple::ppc64le:
578 case Triple::sparcel:
579 case Triple::sparcv9:
582 case Triple::systemz:
584 case Triple::thumbeb:
593 return Triple::MachO;
596 llvm_unreachable("unknown architecture");
599 /// \brief Construct a triple from the string representation provided.
601 /// This stores the string representation and parses the various pieces into
603 Triple::Triple(const Twine &Str)
604 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
605 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
606 ObjectFormat(UnknownObjectFormat) {
607 // Do minimal parsing by hand here.
608 SmallVector<StringRef, 4> Components;
609 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
610 if (Components.size() > 0) {
611 Arch = parseArch(Components[0]);
612 SubArch = parseSubArch(Components[0]);
613 if (Components.size() > 1) {
614 Vendor = parseVendor(Components[1]);
615 if (Components.size() > 2) {
616 OS = parseOS(Components[2]);
617 if (Components.size() > 3) {
618 Environment = parseEnvironment(Components[3]);
619 ObjectFormat = parseFormat(Components[3]);
624 if (ObjectFormat == UnknownObjectFormat)
625 ObjectFormat = getDefaultFormat(*this);
628 /// \brief Construct a triple from string representations of the architecture,
631 /// This joins each argument into a canonical string representation and parses
632 /// them into enum members. It leaves the environment unknown and omits it from
633 /// the string representation.
634 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
635 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
636 Arch(parseArch(ArchStr.str())),
637 SubArch(parseSubArch(ArchStr.str())),
638 Vendor(parseVendor(VendorStr.str())),
639 OS(parseOS(OSStr.str())),
640 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
641 ObjectFormat = getDefaultFormat(*this);
644 /// \brief Construct a triple from string representations of the architecture,
645 /// vendor, OS, and environment.
647 /// This joins each argument into a canonical string representation and parses
648 /// them into enum members.
649 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
650 const Twine &EnvironmentStr)
651 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
652 EnvironmentStr).str()),
653 Arch(parseArch(ArchStr.str())),
654 SubArch(parseSubArch(ArchStr.str())),
655 Vendor(parseVendor(VendorStr.str())),
656 OS(parseOS(OSStr.str())),
657 Environment(parseEnvironment(EnvironmentStr.str())),
658 ObjectFormat(parseFormat(EnvironmentStr.str())) {
659 if (ObjectFormat == Triple::UnknownObjectFormat)
660 ObjectFormat = getDefaultFormat(*this);
663 std::string Triple::normalize(StringRef Str) {
664 bool IsMinGW32 = false;
665 bool IsCygwin = false;
667 // Parse into components.
668 SmallVector<StringRef, 4> Components;
669 Str.split(Components, '-');
671 // If the first component corresponds to a known architecture, preferentially
672 // use it for the architecture. If the second component corresponds to a
673 // known vendor, preferentially use it for the vendor, etc. This avoids silly
674 // component movement when a component parses as (eg) both a valid arch and a
676 ArchType Arch = UnknownArch;
677 if (Components.size() > 0)
678 Arch = parseArch(Components[0]);
679 VendorType Vendor = UnknownVendor;
680 if (Components.size() > 1)
681 Vendor = parseVendor(Components[1]);
682 OSType OS = UnknownOS;
683 if (Components.size() > 2) {
684 OS = parseOS(Components[2]);
685 IsCygwin = Components[2].startswith("cygwin");
686 IsMinGW32 = Components[2].startswith("mingw");
688 EnvironmentType Environment = UnknownEnvironment;
689 if (Components.size() > 3)
690 Environment = parseEnvironment(Components[3]);
691 ObjectFormatType ObjectFormat = UnknownObjectFormat;
692 if (Components.size() > 4)
693 ObjectFormat = parseFormat(Components[4]);
695 // Note which components are already in their final position. These will not
698 Found[0] = Arch != UnknownArch;
699 Found[1] = Vendor != UnknownVendor;
700 Found[2] = OS != UnknownOS;
701 Found[3] = Environment != UnknownEnvironment;
703 // If they are not there already, permute the components into their canonical
704 // positions by seeing if they parse as a valid architecture, and if so moving
705 // the component to the architecture position etc.
706 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
708 continue; // Already in the canonical position.
710 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
711 // Do not reparse any components that already matched.
712 if (Idx < array_lengthof(Found) && Found[Idx])
715 // Does this component parse as valid for the target position?
717 StringRef Comp = Components[Idx];
719 default: llvm_unreachable("unexpected component type!");
721 Arch = parseArch(Comp);
722 Valid = Arch != UnknownArch;
725 Vendor = parseVendor(Comp);
726 Valid = Vendor != UnknownVendor;
730 IsCygwin = Comp.startswith("cygwin");
731 IsMinGW32 = Comp.startswith("mingw");
732 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
735 Environment = parseEnvironment(Comp);
736 Valid = Environment != UnknownEnvironment;
738 ObjectFormat = parseFormat(Comp);
739 Valid = ObjectFormat != UnknownObjectFormat;
744 continue; // Nope, try the next component.
746 // Move the component to the target position, pushing any non-fixed
747 // components that are in the way to the right. This tends to give
748 // good results in the common cases of a forgotten vendor component
749 // or a wrongly positioned environment.
751 // Insert left, pushing the existing components to the right. For
752 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
753 StringRef CurrentComponent(""); // The empty component.
754 // Replace the component we are moving with an empty component.
755 std::swap(CurrentComponent, Components[Idx]);
756 // Insert the component being moved at Pos, displacing any existing
757 // components to the right.
758 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
759 // Skip over any fixed components.
760 while (i < array_lengthof(Found) && Found[i])
762 // Place the component at the new position, getting the component
763 // that was at this position - it will be moved right.
764 std::swap(CurrentComponent, Components[i]);
766 } else if (Pos > Idx) {
767 // Push right by inserting empty components until the component at Idx
768 // reaches the target position Pos. For example, pc-a -> -pc-a when
769 // moving pc to the second position.
771 // Insert one empty component at Idx.
772 StringRef CurrentComponent(""); // The empty component.
773 for (unsigned i = Idx; i < Components.size();) {
774 // Place the component at the new position, getting the component
775 // that was at this position - it will be moved right.
776 std::swap(CurrentComponent, Components[i]);
777 // If it was placed on top of an empty component then we are done.
778 if (CurrentComponent.empty())
780 // Advance to the next component, skipping any fixed components.
781 while (++i < array_lengthof(Found) && Found[i])
784 // The last component was pushed off the end - append it.
785 if (!CurrentComponent.empty())
786 Components.push_back(CurrentComponent);
788 // Advance Idx to the component's new position.
789 while (++Idx < array_lengthof(Found) && Found[Idx])
791 } while (Idx < Pos); // Add more until the final position is reached.
793 assert(Pos < Components.size() && Components[Pos] == Comp &&
794 "Component moved wrong!");
800 // Special case logic goes here. At this point Arch, Vendor and OS have the
801 // correct values for the computed components.
802 std::string NormalizedEnvironment;
803 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
804 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
805 if (AndroidVersion.empty()) {
806 Components[3] = "android";
808 NormalizedEnvironment = Twine("android", AndroidVersion).str();
809 Components[3] = NormalizedEnvironment;
813 if (OS == Triple::Win32) {
814 Components.resize(4);
815 Components[2] = "windows";
816 if (Environment == UnknownEnvironment) {
817 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
818 Components[3] = "msvc";
820 Components[3] = getObjectFormatTypeName(ObjectFormat);
822 } else if (IsMinGW32) {
823 Components.resize(4);
824 Components[2] = "windows";
825 Components[3] = "gnu";
826 } else if (IsCygwin) {
827 Components.resize(4);
828 Components[2] = "windows";
829 Components[3] = "cygnus";
831 if (IsMinGW32 || IsCygwin ||
832 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
833 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
834 Components.resize(5);
835 Components[4] = getObjectFormatTypeName(ObjectFormat);
839 // Stick the corrected components back together to form the normalized string.
840 std::string Normalized;
841 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
842 if (i) Normalized += '-';
843 Normalized += Components[i];
848 StringRef Triple::getArchName() const {
849 return StringRef(Data).split('-').first; // Isolate first component
852 StringRef Triple::getVendorName() const {
853 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
854 return Tmp.split('-').first; // Isolate second component
857 StringRef Triple::getOSName() const {
858 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
859 Tmp = Tmp.split('-').second; // Strip second component
860 return Tmp.split('-').first; // Isolate third component
863 StringRef Triple::getEnvironmentName() const {
864 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
865 Tmp = Tmp.split('-').second; // Strip second component
866 return Tmp.split('-').second; // Strip third component
869 StringRef Triple::getOSAndEnvironmentName() const {
870 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
871 return Tmp.split('-').second; // Strip second component
874 static unsigned EatNumber(StringRef &Str) {
875 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
879 // Consume the leading digit.
880 Result = Result*10 + (Str[0] - '0');
884 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
889 static void parseVersionFromName(StringRef Name, unsigned &Major,
890 unsigned &Minor, unsigned &Micro) {
891 // Any unset version defaults to 0.
892 Major = Minor = Micro = 0;
894 // Parse up to three components.
895 unsigned *Components[3] = {&Major, &Minor, &Micro};
896 for (unsigned i = 0; i != 3; ++i) {
897 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
900 // Consume the leading number.
901 *Components[i] = EatNumber(Name);
903 // Consume the separator, if present.
904 if (Name.startswith("."))
905 Name = Name.substr(1);
909 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
910 unsigned &Micro) const {
911 StringRef EnvironmentName = getEnvironmentName();
912 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
913 if (EnvironmentName.startswith(EnvironmentTypeName))
914 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
916 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
919 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
920 unsigned &Micro) const {
921 StringRef OSName = getOSName();
922 // Assume that the OS portion of the triple starts with the canonical name.
923 StringRef OSTypeName = getOSTypeName(getOS());
924 if (OSName.startswith(OSTypeName))
925 OSName = OSName.substr(OSTypeName.size());
927 parseVersionFromName(OSName, Major, Minor, Micro);
930 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
931 unsigned &Micro) const {
932 getOSVersion(Major, Minor, Micro);
935 default: llvm_unreachable("unexpected OS for Darwin triple");
937 // Default to darwin8, i.e., MacOSX 10.4.
940 // Darwin version numbers are skewed from OS X versions.
959 // Ignore the version from the triple. This is only handled because the
960 // the clang driver combines OS X and IOS support into a common Darwin
961 // toolchain that wants to know the OS X version number even when targeting
971 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
972 unsigned &Micro) const {
974 default: llvm_unreachable("unexpected OS for Darwin triple");
977 // Ignore the version from the triple. This is only handled because the
978 // the clang driver combines OS X and IOS support into a common Darwin
979 // toolchain that wants to know the iOS version number even when targeting
987 getOSVersion(Major, Minor, Micro);
988 // Default to 5.0 (or 7.0 for arm64).
990 Major = (getArch() == aarch64) ? 7 : 5;
993 llvm_unreachable("conflicting triple info");
997 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
998 unsigned &Micro) const {
1000 default: llvm_unreachable("unexpected OS for Darwin triple");
1003 // Ignore the version from the triple. This is only handled because the
1004 // the clang driver combines OS X and IOS support into a common Darwin
1005 // toolchain that wants to know the iOS version number even when targeting
1012 getOSVersion(Major, Minor, Micro);
1017 llvm_unreachable("conflicting triple info");
1021 void Triple::setTriple(const Twine &Str) {
1022 *this = Triple(Str);
1025 void Triple::setArch(ArchType Kind) {
1026 setArchName(getArchTypeName(Kind));
1029 void Triple::setVendor(VendorType Kind) {
1030 setVendorName(getVendorTypeName(Kind));
1033 void Triple::setOS(OSType Kind) {
1034 setOSName(getOSTypeName(Kind));
1037 void Triple::setEnvironment(EnvironmentType Kind) {
1038 if (ObjectFormat == getDefaultFormat(*this))
1039 return setEnvironmentName(getEnvironmentTypeName(Kind));
1041 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1042 getObjectFormatTypeName(ObjectFormat)).str());
1045 void Triple::setObjectFormat(ObjectFormatType Kind) {
1046 if (Environment == UnknownEnvironment)
1047 return setEnvironmentName(getObjectFormatTypeName(Kind));
1049 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1050 getObjectFormatTypeName(Kind)).str());
1053 void Triple::setArchName(StringRef Str) {
1054 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1055 SmallString<64> Triple;
1058 Triple += getVendorName();
1060 Triple += getOSAndEnvironmentName();
1064 void Triple::setVendorName(StringRef Str) {
1065 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1068 void Triple::setOSName(StringRef Str) {
1069 if (hasEnvironment())
1070 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1071 "-" + getEnvironmentName());
1073 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1076 void Triple::setEnvironmentName(StringRef Str) {
1077 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1081 void Triple::setOSAndEnvironmentName(StringRef Str) {
1082 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1085 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1087 case llvm::Triple::UnknownArch:
1090 case llvm::Triple::avr:
1091 case llvm::Triple::msp430:
1094 case llvm::Triple::arm:
1095 case llvm::Triple::armeb:
1096 case llvm::Triple::hexagon:
1097 case llvm::Triple::le32:
1098 case llvm::Triple::mips:
1099 case llvm::Triple::mipsel:
1100 case llvm::Triple::nvptx:
1101 case llvm::Triple::ppc:
1102 case llvm::Triple::r600:
1103 case llvm::Triple::sparc:
1104 case llvm::Triple::sparcel:
1105 case llvm::Triple::tce:
1106 case llvm::Triple::thumb:
1107 case llvm::Triple::thumbeb:
1108 case llvm::Triple::x86:
1109 case llvm::Triple::xcore:
1110 case llvm::Triple::amdil:
1111 case llvm::Triple::hsail:
1112 case llvm::Triple::spir:
1113 case llvm::Triple::kalimba:
1114 case llvm::Triple::shave:
1115 case llvm::Triple::wasm32:
1118 case llvm::Triple::aarch64:
1119 case llvm::Triple::aarch64_be:
1120 case llvm::Triple::amdgcn:
1121 case llvm::Triple::bpfel:
1122 case llvm::Triple::bpfeb:
1123 case llvm::Triple::le64:
1124 case llvm::Triple::mips64:
1125 case llvm::Triple::mips64el:
1126 case llvm::Triple::nvptx64:
1127 case llvm::Triple::ppc64:
1128 case llvm::Triple::ppc64le:
1129 case llvm::Triple::sparcv9:
1130 case llvm::Triple::systemz:
1131 case llvm::Triple::x86_64:
1132 case llvm::Triple::amdil64:
1133 case llvm::Triple::hsail64:
1134 case llvm::Triple::spir64:
1135 case llvm::Triple::wasm64:
1138 llvm_unreachable("Invalid architecture value");
1141 bool Triple::isArch64Bit() const {
1142 return getArchPointerBitWidth(getArch()) == 64;
1145 bool Triple::isArch32Bit() const {
1146 return getArchPointerBitWidth(getArch()) == 32;
1149 bool Triple::isArch16Bit() const {
1150 return getArchPointerBitWidth(getArch()) == 16;
1153 Triple Triple::get32BitArchVariant() const {
1155 switch (getArch()) {
1156 case Triple::UnknownArch:
1157 case Triple::amdgcn:
1161 case Triple::msp430:
1162 case Triple::systemz:
1163 case Triple::ppc64le:
1164 T.setArch(UnknownArch);
1172 case Triple::hexagon:
1173 case Triple::kalimba:
1176 case Triple::mipsel:
1181 case Triple::sparcel:
1184 case Triple::thumbeb:
1188 case Triple::wasm32:
1192 case Triple::aarch64: T.setArch(Triple::arm); break;
1193 case Triple::aarch64_be: T.setArch(Triple::armeb); break;
1194 case Triple::le64: T.setArch(Triple::le32); break;
1195 case Triple::mips64: T.setArch(Triple::mips); break;
1196 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1197 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1198 case Triple::ppc64: T.setArch(Triple::ppc); break;
1199 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1200 case Triple::x86_64: T.setArch(Triple::x86); break;
1201 case Triple::amdil64: T.setArch(Triple::amdil); break;
1202 case Triple::hsail64: T.setArch(Triple::hsail); break;
1203 case Triple::spir64: T.setArch(Triple::spir); break;
1204 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1209 Triple Triple::get64BitArchVariant() const {
1211 switch (getArch()) {
1212 case Triple::UnknownArch:
1214 case Triple::hexagon:
1215 case Triple::kalimba:
1216 case Triple::msp430:
1220 case Triple::sparcel:
1222 T.setArch(UnknownArch);
1225 case Triple::aarch64:
1226 case Triple::aarch64_be:
1230 case Triple::amdil64:
1231 case Triple::amdgcn:
1232 case Triple::hsail64:
1233 case Triple::spir64:
1234 case Triple::mips64:
1235 case Triple::mips64el:
1236 case Triple::nvptx64:
1238 case Triple::ppc64le:
1239 case Triple::sparcv9:
1240 case Triple::systemz:
1241 case Triple::x86_64:
1242 case Triple::wasm64:
1246 case Triple::arm: T.setArch(Triple::aarch64); break;
1247 case Triple::armeb: T.setArch(Triple::aarch64_be); break;
1248 case Triple::le32: T.setArch(Triple::le64); break;
1249 case Triple::mips: T.setArch(Triple::mips64); break;
1250 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1251 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1252 case Triple::ppc: T.setArch(Triple::ppc64); break;
1253 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1254 case Triple::x86: T.setArch(Triple::x86_64); break;
1255 case Triple::amdil: T.setArch(Triple::amdil64); break;
1256 case Triple::hsail: T.setArch(Triple::hsail64); break;
1257 case Triple::spir: T.setArch(Triple::spir64); break;
1258 case Triple::thumb: T.setArch(Triple::aarch64); break;
1259 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break;
1260 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1265 Triple Triple::getBigEndianArchVariant() const {
1267 switch (getArch()) {
1268 case Triple::UnknownArch:
1269 case Triple::amdgcn:
1270 case Triple::amdil64:
1273 case Triple::hexagon:
1274 case Triple::hsail64:
1276 case Triple::kalimba:
1279 case Triple::msp430:
1280 case Triple::nvptx64:
1284 case Triple::spir64:
1286 case Triple::wasm32:
1287 case Triple::wasm64:
1289 case Triple::x86_64:
1292 // ARM is intentionally unsupported here, changing the architecture would
1293 // drop any arch suffixes.
1296 T.setArch(UnknownArch);
1299 case Triple::aarch64_be:
1302 case Triple::mips64:
1307 case Triple::sparcv9:
1308 case Triple::systemz:
1310 case Triple::thumbeb:
1311 // Already big endian.
1314 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1315 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1316 case Triple::mips64el:T.setArch(Triple::mips64); break;
1317 case Triple::mipsel: T.setArch(Triple::mips); break;
1318 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1319 case Triple::sparcel: T.setArch(Triple::sparc); break;
1324 Triple Triple::getLittleEndianArchVariant() const {
1326 switch (getArch()) {
1327 case Triple::UnknownArch:
1329 case Triple::sparcv9:
1330 case Triple::systemz:
1333 // ARM is intentionally unsupported here, changing the architecture would
1334 // drop any arch suffixes.
1336 case Triple::thumbeb:
1337 T.setArch(UnknownArch);
1340 case Triple::aarch64:
1341 case Triple::amdgcn:
1342 case Triple::amdil64:
1347 case Triple::hexagon:
1348 case Triple::hsail64:
1350 case Triple::kalimba:
1353 case Triple::mips64el:
1354 case Triple::mipsel:
1355 case Triple::msp430:
1356 case Triple::nvptx64:
1358 case Triple::ppc64le:
1361 case Triple::sparcel:
1362 case Triple::spir64:
1365 case Triple::wasm32:
1366 case Triple::wasm64:
1368 case Triple::x86_64:
1370 // Already little endian.
1373 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1374 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1375 case Triple::mips64: T.setArch(Triple::mips64el); break;
1376 case Triple::mips: T.setArch(Triple::mipsel); break;
1377 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1378 case Triple::sparc: T.setArch(Triple::sparcel); break;
1383 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1385 MArch = getArchName();
1386 MArch = ARM::getCanonicalArchName(MArch);
1388 // Some defaults are forced.
1390 case llvm::Triple::FreeBSD:
1391 case llvm::Triple::NetBSD:
1392 if (!MArch.empty() && MArch == "v6")
1393 return "arm1176jzf-s";
1395 case llvm::Triple::Win32:
1396 // FIXME: this is invalid for WindowsCE
1398 case llvm::Triple::MacOSX:
1399 case llvm::Triple::IOS:
1400 case llvm::Triple::WatchOS:
1411 StringRef CPU = ARM::getDefaultCPU(MArch);
1415 // If no specific architecture version is requested, return the minimum CPU
1416 // required by the OS and environment.
1418 case llvm::Triple::NetBSD:
1419 switch (getEnvironment()) {
1420 case llvm::Triple::GNUEABIHF:
1421 case llvm::Triple::GNUEABI:
1422 case llvm::Triple::EABIHF:
1423 case llvm::Triple::EABI:
1424 return "arm926ej-s";
1428 case llvm::Triple::NaCl:
1431 switch (getEnvironment()) {
1432 case llvm::Triple::EABIHF:
1433 case llvm::Triple::GNUEABIHF:
1434 return "arm1176jzf-s";
1440 llvm_unreachable("invalid arch name");