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;
523 return Triple::NoSubArch;
527 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
529 case Triple::UnknownObjectFormat: return "";
530 case Triple::COFF: return "coff";
531 case Triple::ELF: return "elf";
532 case Triple::MachO: return "macho";
534 llvm_unreachable("unknown object format type");
537 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
538 switch (T.getArch()) {
541 case Triple::hexagon:
545 case Triple::mips64el:
549 case Triple::sparcv9:
550 case Triple::systemz:
552 case Triple::ppc64le:
558 return Triple::MachO;
563 // Unknown for now, until an object format is specified.
564 return Triple::UnknownObjectFormat;
568 return Triple::MachO;
569 else if (T.isOSWindows())
574 /// \brief Construct a triple from the string representation provided.
576 /// This stores the string representation and parses the various pieces into
578 Triple::Triple(const Twine &Str)
579 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
580 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
581 ObjectFormat(UnknownObjectFormat) {
582 // Do minimal parsing by hand here.
583 SmallVector<StringRef, 4> Components;
584 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
585 if (Components.size() > 0) {
586 Arch = parseArch(Components[0]);
587 SubArch = parseSubArch(Components[0]);
588 if (Components.size() > 1) {
589 Vendor = parseVendor(Components[1]);
590 if (Components.size() > 2) {
591 OS = parseOS(Components[2]);
592 if (Components.size() > 3) {
593 Environment = parseEnvironment(Components[3]);
594 ObjectFormat = parseFormat(Components[3]);
599 if (ObjectFormat == UnknownObjectFormat)
600 ObjectFormat = getDefaultFormat(*this);
603 /// \brief Construct a triple from string representations of the architecture,
606 /// This joins each argument into a canonical string representation and parses
607 /// them into enum members. It leaves the environment unknown and omits it from
608 /// the string representation.
609 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
610 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
611 Arch(parseArch(ArchStr.str())),
612 SubArch(parseSubArch(ArchStr.str())),
613 Vendor(parseVendor(VendorStr.str())),
614 OS(parseOS(OSStr.str())),
615 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
616 ObjectFormat = getDefaultFormat(*this);
619 /// \brief Construct a triple from string representations of the architecture,
620 /// vendor, OS, and environment.
622 /// This joins each argument into a canonical string representation and parses
623 /// them into enum members.
624 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
625 const Twine &EnvironmentStr)
626 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
627 EnvironmentStr).str()),
628 Arch(parseArch(ArchStr.str())),
629 SubArch(parseSubArch(ArchStr.str())),
630 Vendor(parseVendor(VendorStr.str())),
631 OS(parseOS(OSStr.str())),
632 Environment(parseEnvironment(EnvironmentStr.str())),
633 ObjectFormat(parseFormat(EnvironmentStr.str())) {
634 if (ObjectFormat == Triple::UnknownObjectFormat)
635 ObjectFormat = getDefaultFormat(*this);
638 std::string Triple::normalize(StringRef Str) {
639 bool IsMinGW32 = false;
640 bool IsCygwin = false;
642 // Parse into components.
643 SmallVector<StringRef, 4> Components;
644 Str.split(Components, '-');
646 // If the first component corresponds to a known architecture, preferentially
647 // use it for the architecture. If the second component corresponds to a
648 // known vendor, preferentially use it for the vendor, etc. This avoids silly
649 // component movement when a component parses as (eg) both a valid arch and a
651 ArchType Arch = UnknownArch;
652 if (Components.size() > 0)
653 Arch = parseArch(Components[0]);
654 VendorType Vendor = UnknownVendor;
655 if (Components.size() > 1)
656 Vendor = parseVendor(Components[1]);
657 OSType OS = UnknownOS;
658 if (Components.size() > 2) {
659 OS = parseOS(Components[2]);
660 IsCygwin = Components[2].startswith("cygwin");
661 IsMinGW32 = Components[2].startswith("mingw");
663 EnvironmentType Environment = UnknownEnvironment;
664 if (Components.size() > 3)
665 Environment = parseEnvironment(Components[3]);
666 ObjectFormatType ObjectFormat = UnknownObjectFormat;
667 if (Components.size() > 4)
668 ObjectFormat = parseFormat(Components[4]);
670 // Note which components are already in their final position. These will not
673 Found[0] = Arch != UnknownArch;
674 Found[1] = Vendor != UnknownVendor;
675 Found[2] = OS != UnknownOS;
676 Found[3] = Environment != UnknownEnvironment;
678 // If they are not there already, permute the components into their canonical
679 // positions by seeing if they parse as a valid architecture, and if so moving
680 // the component to the architecture position etc.
681 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
683 continue; // Already in the canonical position.
685 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
686 // Do not reparse any components that already matched.
687 if (Idx < array_lengthof(Found) && Found[Idx])
690 // Does this component parse as valid for the target position?
692 StringRef Comp = Components[Idx];
694 default: llvm_unreachable("unexpected component type!");
696 Arch = parseArch(Comp);
697 Valid = Arch != UnknownArch;
700 Vendor = parseVendor(Comp);
701 Valid = Vendor != UnknownVendor;
705 IsCygwin = Comp.startswith("cygwin");
706 IsMinGW32 = Comp.startswith("mingw");
707 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
710 Environment = parseEnvironment(Comp);
711 Valid = Environment != UnknownEnvironment;
713 ObjectFormat = parseFormat(Comp);
714 Valid = ObjectFormat != UnknownObjectFormat;
719 continue; // Nope, try the next component.
721 // Move the component to the target position, pushing any non-fixed
722 // components that are in the way to the right. This tends to give
723 // good results in the common cases of a forgotten vendor component
724 // or a wrongly positioned environment.
726 // Insert left, pushing the existing components to the right. For
727 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
728 StringRef CurrentComponent(""); // The empty component.
729 // Replace the component we are moving with an empty component.
730 std::swap(CurrentComponent, Components[Idx]);
731 // Insert the component being moved at Pos, displacing any existing
732 // components to the right.
733 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
734 // Skip over any fixed components.
735 while (i < array_lengthof(Found) && Found[i])
737 // Place the component at the new position, getting the component
738 // that was at this position - it will be moved right.
739 std::swap(CurrentComponent, Components[i]);
741 } else if (Pos > Idx) {
742 // Push right by inserting empty components until the component at Idx
743 // reaches the target position Pos. For example, pc-a -> -pc-a when
744 // moving pc to the second position.
746 // Insert one empty component at Idx.
747 StringRef CurrentComponent(""); // The empty component.
748 for (unsigned i = Idx; i < Components.size();) {
749 // Place the component at the new position, getting the component
750 // that was at this position - it will be moved right.
751 std::swap(CurrentComponent, Components[i]);
752 // If it was placed on top of an empty component then we are done.
753 if (CurrentComponent.empty())
755 // Advance to the next component, skipping any fixed components.
756 while (++i < array_lengthof(Found) && Found[i])
759 // The last component was pushed off the end - append it.
760 if (!CurrentComponent.empty())
761 Components.push_back(CurrentComponent);
763 // Advance Idx to the component's new position.
764 while (++Idx < array_lengthof(Found) && Found[Idx])
766 } while (Idx < Pos); // Add more until the final position is reached.
768 assert(Pos < Components.size() && Components[Pos] == Comp &&
769 "Component moved wrong!");
775 // Special case logic goes here. At this point Arch, Vendor and OS have the
776 // correct values for the computed components.
777 std::string NormalizedEnvironment;
778 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
779 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
780 if (AndroidVersion.empty()) {
781 Components[3] = "android";
783 NormalizedEnvironment = Twine("android", AndroidVersion).str();
784 Components[3] = NormalizedEnvironment;
788 if (OS == Triple::Win32) {
789 Components.resize(4);
790 Components[2] = "windows";
791 if (Environment == UnknownEnvironment) {
792 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
793 Components[3] = "msvc";
795 Components[3] = getObjectFormatTypeName(ObjectFormat);
797 } else if (IsMinGW32) {
798 Components.resize(4);
799 Components[2] = "windows";
800 Components[3] = "gnu";
801 } else if (IsCygwin) {
802 Components.resize(4);
803 Components[2] = "windows";
804 Components[3] = "cygnus";
806 if (IsMinGW32 || IsCygwin ||
807 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
808 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
809 Components.resize(5);
810 Components[4] = getObjectFormatTypeName(ObjectFormat);
814 // Stick the corrected components back together to form the normalized string.
815 std::string Normalized;
816 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
817 if (i) Normalized += '-';
818 Normalized += Components[i];
823 StringRef Triple::getArchName() const {
824 return StringRef(Data).split('-').first; // Isolate first component
827 StringRef Triple::getVendorName() const {
828 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
829 return Tmp.split('-').first; // Isolate second component
832 StringRef Triple::getOSName() const {
833 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
834 Tmp = Tmp.split('-').second; // Strip second component
835 return Tmp.split('-').first; // Isolate third component
838 StringRef Triple::getEnvironmentName() const {
839 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
840 Tmp = Tmp.split('-').second; // Strip second component
841 return Tmp.split('-').second; // Strip third component
844 StringRef Triple::getOSAndEnvironmentName() const {
845 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
846 return Tmp.split('-').second; // Strip second component
849 static unsigned EatNumber(StringRef &Str) {
850 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
854 // Consume the leading digit.
855 Result = Result*10 + (Str[0] - '0');
859 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
864 static void parseVersionFromName(StringRef Name, unsigned &Major,
865 unsigned &Minor, unsigned &Micro) {
866 // Any unset version defaults to 0.
867 Major = Minor = Micro = 0;
869 // Parse up to three components.
870 unsigned *Components[3] = {&Major, &Minor, &Micro};
871 for (unsigned i = 0; i != 3; ++i) {
872 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
875 // Consume the leading number.
876 *Components[i] = EatNumber(Name);
878 // Consume the separator, if present.
879 if (Name.startswith("."))
880 Name = Name.substr(1);
884 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
885 unsigned &Micro) const {
886 StringRef EnvironmentName = getEnvironmentName();
887 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
888 if (EnvironmentName.startswith(EnvironmentTypeName))
889 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
891 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
894 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
895 unsigned &Micro) const {
896 StringRef OSName = getOSName();
897 // Assume that the OS portion of the triple starts with the canonical name.
898 StringRef OSTypeName = getOSTypeName(getOS());
899 if (OSName.startswith(OSTypeName))
900 OSName = OSName.substr(OSTypeName.size());
902 parseVersionFromName(OSName, Major, Minor, Micro);
905 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
906 unsigned &Micro) const {
907 getOSVersion(Major, Minor, Micro);
910 default: llvm_unreachable("unexpected OS for Darwin triple");
912 // Default to darwin8, i.e., MacOSX 10.4.
915 // Darwin version numbers are skewed from OS X versions.
934 // Ignore the version from the triple. This is only handled because the
935 // the clang driver combines OS X and IOS support into a common Darwin
936 // toolchain that wants to know the OS X version number even when targeting
946 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
947 unsigned &Micro) const {
949 default: llvm_unreachable("unexpected OS for Darwin triple");
952 // Ignore the version from the triple. This is only handled because the
953 // the clang driver combines OS X and IOS support into a common Darwin
954 // toolchain that wants to know the iOS version number even when targeting
962 getOSVersion(Major, Minor, Micro);
963 // Default to 5.0 (or 7.0 for arm64).
965 Major = (getArch() == aarch64) ? 7 : 5;
968 llvm_unreachable("conflicting triple info");
972 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
973 unsigned &Micro) const {
975 default: llvm_unreachable("unexpected OS for Darwin triple");
978 // Ignore the version from the triple. This is only handled because the
979 // the clang driver combines OS X and IOS support into a common Darwin
980 // toolchain that wants to know the iOS version number even when targeting
987 getOSVersion(Major, Minor, Micro);
992 llvm_unreachable("conflicting triple info");
996 void Triple::setTriple(const Twine &Str) {
1000 void Triple::setArch(ArchType Kind) {
1001 setArchName(getArchTypeName(Kind));
1004 void Triple::setVendor(VendorType Kind) {
1005 setVendorName(getVendorTypeName(Kind));
1008 void Triple::setOS(OSType Kind) {
1009 setOSName(getOSTypeName(Kind));
1012 void Triple::setEnvironment(EnvironmentType Kind) {
1013 if (ObjectFormat == getDefaultFormat(*this))
1014 return setEnvironmentName(getEnvironmentTypeName(Kind));
1016 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1017 getObjectFormatTypeName(ObjectFormat)).str());
1020 void Triple::setObjectFormat(ObjectFormatType Kind) {
1021 if (Environment == UnknownEnvironment)
1022 return setEnvironmentName(getObjectFormatTypeName(Kind));
1024 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1025 getObjectFormatTypeName(Kind)).str());
1028 void Triple::setArchName(StringRef Str) {
1029 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1030 SmallString<64> Triple;
1033 Triple += getVendorName();
1035 Triple += getOSAndEnvironmentName();
1039 void Triple::setVendorName(StringRef Str) {
1040 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1043 void Triple::setOSName(StringRef Str) {
1044 if (hasEnvironment())
1045 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1046 "-" + getEnvironmentName());
1048 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1051 void Triple::setEnvironmentName(StringRef Str) {
1052 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1056 void Triple::setOSAndEnvironmentName(StringRef Str) {
1057 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1060 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1062 case llvm::Triple::UnknownArch:
1065 case llvm::Triple::avr:
1066 case llvm::Triple::msp430:
1069 case llvm::Triple::arm:
1070 case llvm::Triple::armeb:
1071 case llvm::Triple::hexagon:
1072 case llvm::Triple::le32:
1073 case llvm::Triple::mips:
1074 case llvm::Triple::mipsel:
1075 case llvm::Triple::nvptx:
1076 case llvm::Triple::ppc:
1077 case llvm::Triple::r600:
1078 case llvm::Triple::sparc:
1079 case llvm::Triple::sparcel:
1080 case llvm::Triple::tce:
1081 case llvm::Triple::thumb:
1082 case llvm::Triple::thumbeb:
1083 case llvm::Triple::x86:
1084 case llvm::Triple::xcore:
1085 case llvm::Triple::amdil:
1086 case llvm::Triple::hsail:
1087 case llvm::Triple::spir:
1088 case llvm::Triple::kalimba:
1089 case llvm::Triple::shave:
1090 case llvm::Triple::wasm32:
1093 case llvm::Triple::aarch64:
1094 case llvm::Triple::aarch64_be:
1095 case llvm::Triple::amdgcn:
1096 case llvm::Triple::bpfel:
1097 case llvm::Triple::bpfeb:
1098 case llvm::Triple::le64:
1099 case llvm::Triple::mips64:
1100 case llvm::Triple::mips64el:
1101 case llvm::Triple::nvptx64:
1102 case llvm::Triple::ppc64:
1103 case llvm::Triple::ppc64le:
1104 case llvm::Triple::sparcv9:
1105 case llvm::Triple::systemz:
1106 case llvm::Triple::x86_64:
1107 case llvm::Triple::amdil64:
1108 case llvm::Triple::hsail64:
1109 case llvm::Triple::spir64:
1110 case llvm::Triple::wasm64:
1113 llvm_unreachable("Invalid architecture value");
1116 bool Triple::isArch64Bit() const {
1117 return getArchPointerBitWidth(getArch()) == 64;
1120 bool Triple::isArch32Bit() const {
1121 return getArchPointerBitWidth(getArch()) == 32;
1124 bool Triple::isArch16Bit() const {
1125 return getArchPointerBitWidth(getArch()) == 16;
1128 Triple Triple::get32BitArchVariant() const {
1130 switch (getArch()) {
1131 case Triple::UnknownArch:
1132 case Triple::aarch64:
1133 case Triple::aarch64_be:
1134 case Triple::amdgcn:
1138 case Triple::msp430:
1139 case Triple::systemz:
1140 case Triple::ppc64le:
1141 T.setArch(UnknownArch);
1149 case Triple::hexagon:
1150 case Triple::kalimba:
1153 case Triple::mipsel:
1158 case Triple::sparcel:
1161 case Triple::thumbeb:
1165 case Triple::wasm32:
1169 case Triple::le64: T.setArch(Triple::le32); break;
1170 case Triple::mips64: T.setArch(Triple::mips); break;
1171 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1172 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1173 case Triple::ppc64: T.setArch(Triple::ppc); break;
1174 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1175 case Triple::x86_64: T.setArch(Triple::x86); break;
1176 case Triple::amdil64: T.setArch(Triple::amdil); break;
1177 case Triple::hsail64: T.setArch(Triple::hsail); break;
1178 case Triple::spir64: T.setArch(Triple::spir); break;
1179 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1184 Triple Triple::get64BitArchVariant() const {
1186 switch (getArch()) {
1187 case Triple::UnknownArch:
1191 case Triple::hexagon:
1192 case Triple::kalimba:
1193 case Triple::msp430:
1197 case Triple::thumbeb:
1199 case Triple::sparcel:
1201 T.setArch(UnknownArch);
1204 case Triple::aarch64:
1205 case Triple::aarch64_be:
1209 case Triple::amdil64:
1210 case Triple::amdgcn:
1211 case Triple::hsail64:
1212 case Triple::spir64:
1213 case Triple::mips64:
1214 case Triple::mips64el:
1215 case Triple::nvptx64:
1217 case Triple::ppc64le:
1218 case Triple::sparcv9:
1219 case Triple::systemz:
1220 case Triple::x86_64:
1221 case Triple::wasm64:
1225 case Triple::le32: T.setArch(Triple::le64); break;
1226 case Triple::mips: T.setArch(Triple::mips64); break;
1227 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1228 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1229 case Triple::ppc: T.setArch(Triple::ppc64); break;
1230 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1231 case Triple::x86: T.setArch(Triple::x86_64); break;
1232 case Triple::amdil: T.setArch(Triple::amdil64); break;
1233 case Triple::hsail: T.setArch(Triple::hsail64); break;
1234 case Triple::spir: T.setArch(Triple::spir64); break;
1235 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1240 Triple Triple::getBigEndianArchVariant() const {
1242 switch (getArch()) {
1243 case Triple::UnknownArch:
1244 case Triple::amdgcn:
1245 case Triple::amdil64:
1248 case Triple::hexagon:
1249 case Triple::hsail64:
1251 case Triple::kalimba:
1254 case Triple::msp430:
1255 case Triple::nvptx64:
1259 case Triple::spir64:
1261 case Triple::wasm32:
1262 case Triple::wasm64:
1264 case Triple::x86_64:
1267 // ARM is intentionally unsupported here, changing the architecture would
1268 // drop any arch suffixes.
1271 T.setArch(UnknownArch);
1274 case Triple::aarch64_be:
1277 case Triple::mips64:
1282 case Triple::sparcv9:
1283 case Triple::systemz:
1285 case Triple::thumbeb:
1286 // Already big endian.
1289 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1290 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1291 case Triple::mips64el:T.setArch(Triple::mips64); break;
1292 case Triple::mipsel: T.setArch(Triple::mips); break;
1293 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1294 case Triple::sparcel: T.setArch(Triple::sparc); break;
1299 Triple Triple::getLittleEndianArchVariant() const {
1301 switch (getArch()) {
1302 case Triple::UnknownArch:
1304 case Triple::sparcv9:
1305 case Triple::systemz:
1308 // ARM is intentionally unsupported here, changing the architecture would
1309 // drop any arch suffixes.
1311 case Triple::thumbeb:
1312 T.setArch(UnknownArch);
1315 case Triple::aarch64:
1316 case Triple::amdgcn:
1317 case Triple::amdil64:
1322 case Triple::hexagon:
1323 case Triple::hsail64:
1325 case Triple::kalimba:
1328 case Triple::mips64el:
1329 case Triple::mipsel:
1330 case Triple::msp430:
1331 case Triple::nvptx64:
1333 case Triple::ppc64le:
1336 case Triple::sparcel:
1337 case Triple::spir64:
1340 case Triple::wasm32:
1341 case Triple::wasm64:
1343 case Triple::x86_64:
1345 // Already little endian.
1348 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1349 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1350 case Triple::mips64: T.setArch(Triple::mips64el); break;
1351 case Triple::mips: T.setArch(Triple::mipsel); break;
1352 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1353 case Triple::sparc: T.setArch(Triple::sparcel); break;
1358 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1360 MArch = getArchName();
1361 MArch = ARM::getCanonicalArchName(MArch);
1363 // Some defaults are forced.
1365 case llvm::Triple::FreeBSD:
1366 case llvm::Triple::NetBSD:
1367 if (!MArch.empty() && MArch == "v6")
1368 return "arm1176jzf-s";
1370 case llvm::Triple::Win32:
1371 // FIXME: this is invalid for WindowsCE
1373 case llvm::Triple::MacOSX:
1374 case llvm::Triple::IOS:
1375 case llvm::Triple::WatchOS:
1386 StringRef CPU = ARM::getDefaultCPU(MArch);
1390 // If no specific architecture version is requested, return the minimum CPU
1391 // required by the OS and environment.
1393 case llvm::Triple::NetBSD:
1394 switch (getEnvironment()) {
1395 case llvm::Triple::GNUEABIHF:
1396 case llvm::Triple::GNUEABI:
1397 case llvm::Triple::EABIHF:
1398 case llvm::Triple::EABI:
1399 return "arm926ej-s";
1403 case llvm::Triple::NaCl:
1406 switch (getEnvironment()) {
1407 case llvm::Triple::EABIHF:
1408 case llvm::Triple::GNUEABIHF:
1409 return "arm1176jzf-s";
1415 llvm_unreachable("invalid arch name");