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;
493 return Triple::ARMSubArch_v5;
494 case ARM::AK_ARMV5TE:
496 case ARM::AK_IWMMXT2:
498 case ARM::AK_ARMV5TEJ:
499 return Triple::ARMSubArch_v5te;
503 return Triple::ARMSubArch_v6;
505 case ARM::AK_ARMV6ZK:
506 case ARM::AK_ARMV6HL:
507 return Triple::ARMSubArch_v6k;
508 case ARM::AK_ARMV6T2:
509 return Triple::ARMSubArch_v6t2;
511 case ARM::AK_ARMV6SM:
512 return Triple::ARMSubArch_v6m;
517 case ARM::AK_ARMV7HL:
518 return Triple::ARMSubArch_v7;
520 return Triple::ARMSubArch_v7k;
522 return Triple::ARMSubArch_v7m;
524 return Triple::ARMSubArch_v7s;
525 case ARM::AK_ARMV7EM:
526 return Triple::ARMSubArch_v7em;
528 return Triple::ARMSubArch_v8;
529 case ARM::AK_ARMV8_1A:
530 return Triple::ARMSubArch_v8_1a;
532 return Triple::NoSubArch;
536 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
538 case Triple::UnknownObjectFormat: return "";
539 case Triple::COFF: return "coff";
540 case Triple::ELF: return "elf";
541 case Triple::MachO: return "macho";
543 llvm_unreachable("unknown object format type");
546 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
547 switch (T.getArch()) {
550 case Triple::hexagon:
554 case Triple::mips64el:
558 case Triple::sparcv9:
559 case Triple::systemz:
561 case Triple::ppc64le:
567 return Triple::MachO;
572 // Unknown for now, until an object format is specified.
573 return Triple::UnknownObjectFormat;
577 return Triple::MachO;
578 else if (T.isOSWindows())
583 /// \brief Construct a triple from the string representation provided.
585 /// This stores the string representation and parses the various pieces into
587 Triple::Triple(const Twine &Str)
588 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
589 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
590 ObjectFormat(UnknownObjectFormat) {
591 // Do minimal parsing by hand here.
592 SmallVector<StringRef, 4> Components;
593 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
594 if (Components.size() > 0) {
595 Arch = parseArch(Components[0]);
596 SubArch = parseSubArch(Components[0]);
597 if (Components.size() > 1) {
598 Vendor = parseVendor(Components[1]);
599 if (Components.size() > 2) {
600 OS = parseOS(Components[2]);
601 if (Components.size() > 3) {
602 Environment = parseEnvironment(Components[3]);
603 ObjectFormat = parseFormat(Components[3]);
608 if (ObjectFormat == UnknownObjectFormat)
609 ObjectFormat = getDefaultFormat(*this);
612 /// \brief Construct a triple from string representations of the architecture,
615 /// This joins each argument into a canonical string representation and parses
616 /// them into enum members. It leaves the environment unknown and omits it from
617 /// the string representation.
618 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
619 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
620 Arch(parseArch(ArchStr.str())),
621 SubArch(parseSubArch(ArchStr.str())),
622 Vendor(parseVendor(VendorStr.str())),
623 OS(parseOS(OSStr.str())),
624 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
625 ObjectFormat = getDefaultFormat(*this);
628 /// \brief Construct a triple from string representations of the architecture,
629 /// vendor, OS, and environment.
631 /// This joins each argument into a canonical string representation and parses
632 /// them into enum members.
633 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
634 const Twine &EnvironmentStr)
635 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
636 EnvironmentStr).str()),
637 Arch(parseArch(ArchStr.str())),
638 SubArch(parseSubArch(ArchStr.str())),
639 Vendor(parseVendor(VendorStr.str())),
640 OS(parseOS(OSStr.str())),
641 Environment(parseEnvironment(EnvironmentStr.str())),
642 ObjectFormat(parseFormat(EnvironmentStr.str())) {
643 if (ObjectFormat == Triple::UnknownObjectFormat)
644 ObjectFormat = getDefaultFormat(*this);
647 std::string Triple::normalize(StringRef Str) {
648 bool IsMinGW32 = false;
649 bool IsCygwin = false;
651 // Parse into components.
652 SmallVector<StringRef, 4> Components;
653 Str.split(Components, '-');
655 // If the first component corresponds to a known architecture, preferentially
656 // use it for the architecture. If the second component corresponds to a
657 // known vendor, preferentially use it for the vendor, etc. This avoids silly
658 // component movement when a component parses as (eg) both a valid arch and a
660 ArchType Arch = UnknownArch;
661 if (Components.size() > 0)
662 Arch = parseArch(Components[0]);
663 VendorType Vendor = UnknownVendor;
664 if (Components.size() > 1)
665 Vendor = parseVendor(Components[1]);
666 OSType OS = UnknownOS;
667 if (Components.size() > 2) {
668 OS = parseOS(Components[2]);
669 IsCygwin = Components[2].startswith("cygwin");
670 IsMinGW32 = Components[2].startswith("mingw");
672 EnvironmentType Environment = UnknownEnvironment;
673 if (Components.size() > 3)
674 Environment = parseEnvironment(Components[3]);
675 ObjectFormatType ObjectFormat = UnknownObjectFormat;
676 if (Components.size() > 4)
677 ObjectFormat = parseFormat(Components[4]);
679 // Note which components are already in their final position. These will not
682 Found[0] = Arch != UnknownArch;
683 Found[1] = Vendor != UnknownVendor;
684 Found[2] = OS != UnknownOS;
685 Found[3] = Environment != UnknownEnvironment;
687 // If they are not there already, permute the components into their canonical
688 // positions by seeing if they parse as a valid architecture, and if so moving
689 // the component to the architecture position etc.
690 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
692 continue; // Already in the canonical position.
694 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
695 // Do not reparse any components that already matched.
696 if (Idx < array_lengthof(Found) && Found[Idx])
699 // Does this component parse as valid for the target position?
701 StringRef Comp = Components[Idx];
703 default: llvm_unreachable("unexpected component type!");
705 Arch = parseArch(Comp);
706 Valid = Arch != UnknownArch;
709 Vendor = parseVendor(Comp);
710 Valid = Vendor != UnknownVendor;
714 IsCygwin = Comp.startswith("cygwin");
715 IsMinGW32 = Comp.startswith("mingw");
716 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
719 Environment = parseEnvironment(Comp);
720 Valid = Environment != UnknownEnvironment;
722 ObjectFormat = parseFormat(Comp);
723 Valid = ObjectFormat != UnknownObjectFormat;
728 continue; // Nope, try the next component.
730 // Move the component to the target position, pushing any non-fixed
731 // components that are in the way to the right. This tends to give
732 // good results in the common cases of a forgotten vendor component
733 // or a wrongly positioned environment.
735 // Insert left, pushing the existing components to the right. For
736 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
737 StringRef CurrentComponent(""); // The empty component.
738 // Replace the component we are moving with an empty component.
739 std::swap(CurrentComponent, Components[Idx]);
740 // Insert the component being moved at Pos, displacing any existing
741 // components to the right.
742 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
743 // Skip over any fixed components.
744 while (i < array_lengthof(Found) && Found[i])
746 // Place the component at the new position, getting the component
747 // that was at this position - it will be moved right.
748 std::swap(CurrentComponent, Components[i]);
750 } else if (Pos > Idx) {
751 // Push right by inserting empty components until the component at Idx
752 // reaches the target position Pos. For example, pc-a -> -pc-a when
753 // moving pc to the second position.
755 // Insert one empty component at Idx.
756 StringRef CurrentComponent(""); // The empty component.
757 for (unsigned i = Idx; i < Components.size();) {
758 // Place the component at the new position, getting the component
759 // that was at this position - it will be moved right.
760 std::swap(CurrentComponent, Components[i]);
761 // If it was placed on top of an empty component then we are done.
762 if (CurrentComponent.empty())
764 // Advance to the next component, skipping any fixed components.
765 while (++i < array_lengthof(Found) && Found[i])
768 // The last component was pushed off the end - append it.
769 if (!CurrentComponent.empty())
770 Components.push_back(CurrentComponent);
772 // Advance Idx to the component's new position.
773 while (++Idx < array_lengthof(Found) && Found[Idx])
775 } while (Idx < Pos); // Add more until the final position is reached.
777 assert(Pos < Components.size() && Components[Pos] == Comp &&
778 "Component moved wrong!");
784 // Special case logic goes here. At this point Arch, Vendor and OS have the
785 // correct values for the computed components.
786 std::string NormalizedEnvironment;
787 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
788 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
789 if (AndroidVersion.empty()) {
790 Components[3] = "android";
792 NormalizedEnvironment = Twine("android", AndroidVersion).str();
793 Components[3] = NormalizedEnvironment;
797 if (OS == Triple::Win32) {
798 Components.resize(4);
799 Components[2] = "windows";
800 if (Environment == UnknownEnvironment) {
801 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
802 Components[3] = "msvc";
804 Components[3] = getObjectFormatTypeName(ObjectFormat);
806 } else if (IsMinGW32) {
807 Components.resize(4);
808 Components[2] = "windows";
809 Components[3] = "gnu";
810 } else if (IsCygwin) {
811 Components.resize(4);
812 Components[2] = "windows";
813 Components[3] = "cygnus";
815 if (IsMinGW32 || IsCygwin ||
816 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
817 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
818 Components.resize(5);
819 Components[4] = getObjectFormatTypeName(ObjectFormat);
823 // Stick the corrected components back together to form the normalized string.
824 std::string Normalized;
825 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
826 if (i) Normalized += '-';
827 Normalized += Components[i];
832 StringRef Triple::getArchName() const {
833 return StringRef(Data).split('-').first; // Isolate first component
836 StringRef Triple::getVendorName() const {
837 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
838 return Tmp.split('-').first; // Isolate second component
841 StringRef Triple::getOSName() const {
842 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
843 Tmp = Tmp.split('-').second; // Strip second component
844 return Tmp.split('-').first; // Isolate third component
847 StringRef Triple::getEnvironmentName() const {
848 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
849 Tmp = Tmp.split('-').second; // Strip second component
850 return Tmp.split('-').second; // Strip third component
853 StringRef Triple::getOSAndEnvironmentName() const {
854 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
855 return Tmp.split('-').second; // Strip second component
858 static unsigned EatNumber(StringRef &Str) {
859 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
863 // Consume the leading digit.
864 Result = Result*10 + (Str[0] - '0');
868 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
873 static void parseVersionFromName(StringRef Name, unsigned &Major,
874 unsigned &Minor, unsigned &Micro) {
875 // Any unset version defaults to 0.
876 Major = Minor = Micro = 0;
878 // Parse up to three components.
879 unsigned *Components[3] = {&Major, &Minor, &Micro};
880 for (unsigned i = 0; i != 3; ++i) {
881 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
884 // Consume the leading number.
885 *Components[i] = EatNumber(Name);
887 // Consume the separator, if present.
888 if (Name.startswith("."))
889 Name = Name.substr(1);
893 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
894 unsigned &Micro) const {
895 StringRef EnvironmentName = getEnvironmentName();
896 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
897 if (EnvironmentName.startswith(EnvironmentTypeName))
898 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
900 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
903 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
904 unsigned &Micro) const {
905 StringRef OSName = getOSName();
906 // Assume that the OS portion of the triple starts with the canonical name.
907 StringRef OSTypeName = getOSTypeName(getOS());
908 if (OSName.startswith(OSTypeName))
909 OSName = OSName.substr(OSTypeName.size());
911 parseVersionFromName(OSName, Major, Minor, Micro);
914 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
915 unsigned &Micro) const {
916 getOSVersion(Major, Minor, Micro);
919 default: llvm_unreachable("unexpected OS for Darwin triple");
921 // Default to darwin8, i.e., MacOSX 10.4.
924 // Darwin version numbers are skewed from OS X versions.
943 // Ignore the version from the triple. This is only handled because the
944 // the clang driver combines OS X and IOS support into a common Darwin
945 // toolchain that wants to know the OS X version number even when targeting
955 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
956 unsigned &Micro) const {
958 default: llvm_unreachable("unexpected OS for Darwin triple");
961 // Ignore the version from the triple. This is only handled because the
962 // the clang driver combines OS X and IOS support into a common Darwin
963 // toolchain that wants to know the iOS version number even when targeting
971 getOSVersion(Major, Minor, Micro);
972 // Default to 5.0 (or 7.0 for arm64).
974 Major = (getArch() == aarch64) ? 7 : 5;
977 llvm_unreachable("conflicting triple info");
981 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
982 unsigned &Micro) const {
984 default: llvm_unreachable("unexpected OS for Darwin triple");
987 // Ignore the version from the triple. This is only handled because the
988 // the clang driver combines OS X and IOS support into a common Darwin
989 // toolchain that wants to know the iOS version number even when targeting
996 getOSVersion(Major, Minor, Micro);
1001 llvm_unreachable("conflicting triple info");
1005 void Triple::setTriple(const Twine &Str) {
1006 *this = Triple(Str);
1009 void Triple::setArch(ArchType Kind) {
1010 setArchName(getArchTypeName(Kind));
1013 void Triple::setVendor(VendorType Kind) {
1014 setVendorName(getVendorTypeName(Kind));
1017 void Triple::setOS(OSType Kind) {
1018 setOSName(getOSTypeName(Kind));
1021 void Triple::setEnvironment(EnvironmentType Kind) {
1022 if (ObjectFormat == getDefaultFormat(*this))
1023 return setEnvironmentName(getEnvironmentTypeName(Kind));
1025 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1026 getObjectFormatTypeName(ObjectFormat)).str());
1029 void Triple::setObjectFormat(ObjectFormatType Kind) {
1030 if (Environment == UnknownEnvironment)
1031 return setEnvironmentName(getObjectFormatTypeName(Kind));
1033 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1034 getObjectFormatTypeName(Kind)).str());
1037 void Triple::setArchName(StringRef Str) {
1038 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1039 SmallString<64> Triple;
1042 Triple += getVendorName();
1044 Triple += getOSAndEnvironmentName();
1048 void Triple::setVendorName(StringRef Str) {
1049 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1052 void Triple::setOSName(StringRef Str) {
1053 if (hasEnvironment())
1054 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1055 "-" + getEnvironmentName());
1057 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1060 void Triple::setEnvironmentName(StringRef Str) {
1061 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1065 void Triple::setOSAndEnvironmentName(StringRef Str) {
1066 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1069 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1071 case llvm::Triple::UnknownArch:
1074 case llvm::Triple::avr:
1075 case llvm::Triple::msp430:
1078 case llvm::Triple::arm:
1079 case llvm::Triple::armeb:
1080 case llvm::Triple::hexagon:
1081 case llvm::Triple::le32:
1082 case llvm::Triple::mips:
1083 case llvm::Triple::mipsel:
1084 case llvm::Triple::nvptx:
1085 case llvm::Triple::ppc:
1086 case llvm::Triple::r600:
1087 case llvm::Triple::sparc:
1088 case llvm::Triple::sparcel:
1089 case llvm::Triple::tce:
1090 case llvm::Triple::thumb:
1091 case llvm::Triple::thumbeb:
1092 case llvm::Triple::x86:
1093 case llvm::Triple::xcore:
1094 case llvm::Triple::amdil:
1095 case llvm::Triple::hsail:
1096 case llvm::Triple::spir:
1097 case llvm::Triple::kalimba:
1098 case llvm::Triple::shave:
1099 case llvm::Triple::wasm32:
1102 case llvm::Triple::aarch64:
1103 case llvm::Triple::aarch64_be:
1104 case llvm::Triple::amdgcn:
1105 case llvm::Triple::bpfel:
1106 case llvm::Triple::bpfeb:
1107 case llvm::Triple::le64:
1108 case llvm::Triple::mips64:
1109 case llvm::Triple::mips64el:
1110 case llvm::Triple::nvptx64:
1111 case llvm::Triple::ppc64:
1112 case llvm::Triple::ppc64le:
1113 case llvm::Triple::sparcv9:
1114 case llvm::Triple::systemz:
1115 case llvm::Triple::x86_64:
1116 case llvm::Triple::amdil64:
1117 case llvm::Triple::hsail64:
1118 case llvm::Triple::spir64:
1119 case llvm::Triple::wasm64:
1122 llvm_unreachable("Invalid architecture value");
1125 bool Triple::isArch64Bit() const {
1126 return getArchPointerBitWidth(getArch()) == 64;
1129 bool Triple::isArch32Bit() const {
1130 return getArchPointerBitWidth(getArch()) == 32;
1133 bool Triple::isArch16Bit() const {
1134 return getArchPointerBitWidth(getArch()) == 16;
1137 Triple Triple::get32BitArchVariant() const {
1139 switch (getArch()) {
1140 case Triple::UnknownArch:
1141 case Triple::aarch64:
1142 case Triple::aarch64_be:
1143 case Triple::amdgcn:
1147 case Triple::msp430:
1148 case Triple::systemz:
1149 case Triple::ppc64le:
1150 T.setArch(UnknownArch);
1158 case Triple::hexagon:
1159 case Triple::kalimba:
1162 case Triple::mipsel:
1167 case Triple::sparcel:
1170 case Triple::thumbeb:
1174 case Triple::wasm32:
1178 case Triple::le64: T.setArch(Triple::le32); break;
1179 case Triple::mips64: T.setArch(Triple::mips); break;
1180 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1181 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1182 case Triple::ppc64: T.setArch(Triple::ppc); break;
1183 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1184 case Triple::x86_64: T.setArch(Triple::x86); break;
1185 case Triple::amdil64: T.setArch(Triple::amdil); break;
1186 case Triple::hsail64: T.setArch(Triple::hsail); break;
1187 case Triple::spir64: T.setArch(Triple::spir); break;
1188 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1193 Triple Triple::get64BitArchVariant() const {
1195 switch (getArch()) {
1196 case Triple::UnknownArch:
1200 case Triple::hexagon:
1201 case Triple::kalimba:
1202 case Triple::msp430:
1206 case Triple::thumbeb:
1208 case Triple::sparcel:
1210 T.setArch(UnknownArch);
1213 case Triple::aarch64:
1214 case Triple::aarch64_be:
1218 case Triple::amdil64:
1219 case Triple::amdgcn:
1220 case Triple::hsail64:
1221 case Triple::spir64:
1222 case Triple::mips64:
1223 case Triple::mips64el:
1224 case Triple::nvptx64:
1226 case Triple::ppc64le:
1227 case Triple::sparcv9:
1228 case Triple::systemz:
1229 case Triple::x86_64:
1230 case Triple::wasm64:
1234 case Triple::le32: T.setArch(Triple::le64); break;
1235 case Triple::mips: T.setArch(Triple::mips64); break;
1236 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1237 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1238 case Triple::ppc: T.setArch(Triple::ppc64); break;
1239 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1240 case Triple::x86: T.setArch(Triple::x86_64); break;
1241 case Triple::amdil: T.setArch(Triple::amdil64); break;
1242 case Triple::hsail: T.setArch(Triple::hsail64); break;
1243 case Triple::spir: T.setArch(Triple::spir64); break;
1244 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1249 Triple Triple::getBigEndianArchVariant() const {
1251 switch (getArch()) {
1252 case Triple::UnknownArch:
1253 case Triple::amdgcn:
1254 case Triple::amdil64:
1257 case Triple::hexagon:
1258 case Triple::hsail64:
1260 case Triple::kalimba:
1263 case Triple::msp430:
1264 case Triple::nvptx64:
1268 case Triple::spir64:
1270 case Triple::wasm32:
1271 case Triple::wasm64:
1273 case Triple::x86_64:
1276 // ARM is intentionally unsupported here, changing the architecture would
1277 // drop any arch suffixes.
1280 T.setArch(UnknownArch);
1283 case Triple::aarch64_be:
1286 case Triple::mips64:
1291 case Triple::sparcv9:
1292 case Triple::systemz:
1294 case Triple::thumbeb:
1295 // Already big endian.
1298 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1299 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1300 case Triple::mips64el:T.setArch(Triple::mips64); break;
1301 case Triple::mipsel: T.setArch(Triple::mips); break;
1302 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1303 case Triple::sparcel: T.setArch(Triple::sparc); break;
1308 Triple Triple::getLittleEndianArchVariant() const {
1310 switch (getArch()) {
1311 case Triple::UnknownArch:
1313 case Triple::sparcv9:
1314 case Triple::systemz:
1317 // ARM is intentionally unsupported here, changing the architecture would
1318 // drop any arch suffixes.
1320 case Triple::thumbeb:
1321 T.setArch(UnknownArch);
1324 case Triple::aarch64:
1325 case Triple::amdgcn:
1326 case Triple::amdil64:
1331 case Triple::hexagon:
1332 case Triple::hsail64:
1334 case Triple::kalimba:
1337 case Triple::mips64el:
1338 case Triple::mipsel:
1339 case Triple::msp430:
1340 case Triple::nvptx64:
1342 case Triple::ppc64le:
1345 case Triple::sparcel:
1346 case Triple::spir64:
1349 case Triple::wasm32:
1350 case Triple::wasm64:
1352 case Triple::x86_64:
1354 // Already little endian.
1357 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1358 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1359 case Triple::mips64: T.setArch(Triple::mips64el); break;
1360 case Triple::mips: T.setArch(Triple::mipsel); break;
1361 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1362 case Triple::sparc: T.setArch(Triple::sparcel); break;
1367 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1369 MArch = getArchName();
1370 MArch = ARM::getCanonicalArchName(MArch);
1372 // Some defaults are forced.
1374 case llvm::Triple::FreeBSD:
1375 case llvm::Triple::NetBSD:
1376 if (!MArch.empty() && MArch == "v6")
1377 return "arm1176jzf-s";
1379 case llvm::Triple::Win32:
1380 // FIXME: this is invalid for WindowsCE
1389 StringRef CPU = ARM::getDefaultCPU(MArch);
1393 // If no specific architecture version is requested, return the minimum CPU
1394 // required by the OS and environment.
1396 case llvm::Triple::NetBSD:
1397 switch (getEnvironment()) {
1398 case llvm::Triple::GNUEABIHF:
1399 case llvm::Triple::GNUEABI:
1400 case llvm::Triple::EABIHF:
1401 case llvm::Triple::EABI:
1402 return "arm926ej-s";
1406 case llvm::Triple::NaCl:
1409 switch (getEnvironment()) {
1410 case llvm::Triple::EABIHF:
1411 case llvm::Triple::GNUEABIHF:
1412 return "arm1176jzf-s";
1418 llvm_unreachable("invalid arch name");