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 bpfel: return "bpfel";
29 case bpfeb: return "bpfeb";
30 case hexagon: return "hexagon";
31 case mips: return "mips";
32 case mipsel: return "mipsel";
33 case mips64: return "mips64";
34 case mips64el: return "mips64el";
35 case msp430: return "msp430";
36 case ppc64: return "powerpc64";
37 case ppc64le: return "powerpc64le";
38 case ppc: return "powerpc";
39 case r600: return "r600";
40 case amdgcn: return "amdgcn";
41 case sparc: return "sparc";
42 case sparcv9: return "sparcv9";
43 case sparcel: return "sparcel";
44 case systemz: return "s390x";
45 case tce: return "tce";
46 case thumb: return "thumb";
47 case thumbeb: return "thumbeb";
48 case x86: return "i386";
49 case x86_64: return "x86_64";
50 case xcore: return "xcore";
51 case nvptx: return "nvptx";
52 case nvptx64: return "nvptx64";
53 case le32: return "le32";
54 case le64: return "le64";
55 case amdil: return "amdil";
56 case amdil64: return "amdil64";
57 case hsail: return "hsail";
58 case hsail64: return "hsail64";
59 case spir: return "spir";
60 case spir64: return "spir64";
61 case kalimba: return "kalimba";
62 case shave: return "shave";
63 case wasm32: return "wasm32";
64 case wasm64: return "wasm64";
67 llvm_unreachable("Invalid ArchType!");
70 const char *Triple::getArchTypePrefix(ArchType Kind) {
76 case aarch64_be: return "aarch64";
81 case thumbeb: return "arm";
85 case ppc: return "ppc";
90 case mips64el: return "mips";
92 case hexagon: return "hexagon";
95 case r600: return "amdgpu";
98 case bpfeb: return "bpf";
102 case sparc: return "sparc";
104 case systemz: return "s390";
107 case x86_64: return "x86";
109 case xcore: return "xcore";
111 case nvptx: return "nvptx";
112 case nvptx64: return "nvptx";
114 case le32: return "le32";
115 case le64: return "le64";
118 case amdil64: return "amdil";
121 case hsail64: return "hsail";
124 case spir64: return "spir";
125 case kalimba: return "kalimba";
126 case shave: return "shave";
128 case wasm64: return "wasm";
132 const char *Triple::getVendorTypeName(VendorType Kind) {
134 case UnknownVendor: return "unknown";
136 case Apple: return "apple";
137 case PC: return "pc";
138 case SCEI: return "scei";
139 case BGP: return "bgp";
140 case BGQ: return "bgq";
141 case Freescale: return "fsl";
142 case IBM: return "ibm";
143 case ImaginationTechnologies: return "img";
144 case MipsTechnologies: return "mti";
145 case NVIDIA: return "nvidia";
146 case CSR: return "csr";
149 llvm_unreachable("Invalid VendorType!");
152 const char *Triple::getOSTypeName(OSType Kind) {
154 case UnknownOS: return "unknown";
156 case CloudABI: return "cloudabi";
157 case Darwin: return "darwin";
158 case DragonFly: return "dragonfly";
159 case FreeBSD: return "freebsd";
160 case IOS: return "ios";
161 case KFreeBSD: return "kfreebsd";
162 case Linux: return "linux";
163 case Lv2: return "lv2";
164 case MacOSX: return "macosx";
165 case NetBSD: return "netbsd";
166 case OpenBSD: return "openbsd";
167 case Solaris: return "solaris";
168 case Win32: return "windows";
169 case Haiku: return "haiku";
170 case Minix: return "minix";
171 case RTEMS: return "rtems";
172 case NaCl: return "nacl";
173 case CNK: return "cnk";
174 case Bitrig: return "bitrig";
175 case AIX: return "aix";
176 case CUDA: return "cuda";
177 case NVCL: return "nvcl";
178 case AMDHSA: return "amdhsa";
179 case PS4: return "ps4";
182 llvm_unreachable("Invalid OSType");
185 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
187 case UnknownEnvironment: return "unknown";
188 case GNU: return "gnu";
189 case GNUEABIHF: return "gnueabihf";
190 case GNUEABI: return "gnueabi";
191 case GNUX32: return "gnux32";
192 case CODE16: return "code16";
193 case EABI: return "eabi";
194 case EABIHF: return "eabihf";
195 case Android: return "android";
196 case MSVC: return "msvc";
197 case Itanium: return "itanium";
198 case Cygnus: return "cygnus";
199 case AMDOpenCL: return "amdopencl";
200 case CoreCLR: return "coreclr";
203 llvm_unreachable("Invalid EnvironmentType!");
206 static Triple::ArchType parseBPFArch(StringRef ArchName) {
207 if (ArchName.equals("bpf")) {
208 if (sys::IsLittleEndianHost)
209 return Triple::bpfel;
211 return Triple::bpfeb;
212 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
213 return Triple::bpfeb;
214 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
215 return Triple::bpfel;
217 return Triple::UnknownArch;
221 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
222 Triple::ArchType BPFArch(parseBPFArch(Name));
223 return StringSwitch<Triple::ArchType>(Name)
224 .Case("aarch64", aarch64)
225 .Case("aarch64_be", aarch64_be)
226 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
228 .Case("armeb", armeb)
229 .StartsWith("bpf", BPFArch)
231 .Case("mipsel", mipsel)
232 .Case("mips64", mips64)
233 .Case("mips64el", mips64el)
234 .Case("msp430", msp430)
235 .Case("ppc64", ppc64)
238 .Case("ppc64le", ppc64le)
240 .Case("amdgcn", amdgcn)
241 .Case("hexagon", hexagon)
242 .Case("sparc", sparc)
243 .Case("sparcel", sparcel)
244 .Case("sparcv9", sparcv9)
245 .Case("systemz", systemz)
247 .Case("thumb", thumb)
248 .Case("thumbeb", thumbeb)
250 .Case("x86-64", x86_64)
251 .Case("xcore", xcore)
252 .Case("nvptx", nvptx)
253 .Case("nvptx64", nvptx64)
256 .Case("amdil", amdil)
257 .Case("amdil64", amdil64)
258 .Case("hsail", hsail)
259 .Case("hsail64", hsail64)
261 .Case("spir64", spir64)
262 .Case("kalimba", kalimba)
263 .Case("shave", shave)
264 .Case("wasm32", wasm32)
265 .Case("wasm64", wasm64)
266 .Default(UnknownArch);
269 static Triple::ArchType parseARMArch(StringRef ArchName) {
270 unsigned ISA = ARM::parseArchISA(ArchName);
271 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
273 Triple::ArchType arch = Triple::UnknownArch;
275 case ARM::EK_LITTLE: {
281 arch = Triple::thumb;
283 case ARM::IK_AARCH64:
284 arch = Triple::aarch64;
292 arch = Triple::armeb;
295 arch = Triple::thumbeb;
297 case ARM::IK_AARCH64:
298 arch = Triple::aarch64_be;
305 ArchName = ARM::getCanonicalArchName(ArchName);
306 if (ArchName.empty())
307 return Triple::UnknownArch;
309 // Thumb only exists in v4+
310 if (ISA == ARM::IK_THUMB &&
311 (ArchName.startswith("v2") || ArchName.startswith("v3")))
312 return Triple::UnknownArch;
314 // Thumb only for v6m
315 unsigned Profile = ARM::parseArchProfile(ArchName);
316 unsigned Version = ARM::parseArchVersion(ArchName);
317 if (Profile == ARM::PK_M && Version == 6) {
318 if (ENDIAN == ARM::EK_BIG)
319 return Triple::thumbeb;
321 return Triple::thumb;
327 static Triple::ArchType parseArch(StringRef ArchName) {
328 auto AT = StringSwitch<Triple::ArchType>(ArchName)
329 .Cases("i386", "i486", "i586", "i686", Triple::x86)
330 // FIXME: Do we need to support these?
331 .Cases("i786", "i886", "i986", Triple::x86)
332 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
333 .Case("powerpc", Triple::ppc)
334 .Cases("powerpc64", "ppu", Triple::ppc64)
335 .Case("powerpc64le", Triple::ppc64le)
336 .Case("xscale", Triple::arm)
337 .Case("xscaleeb", Triple::armeb)
338 .Case("aarch64", Triple::aarch64)
339 .Case("aarch64_be", Triple::aarch64_be)
340 .Case("arm64", Triple::aarch64)
341 .Case("arm", Triple::arm)
342 .Case("armeb", Triple::armeb)
343 .Case("thumb", Triple::thumb)
344 .Case("thumbeb", Triple::thumbeb)
345 .Case("msp430", Triple::msp430)
346 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
347 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
348 .Cases("mips64", "mips64eb", Triple::mips64)
349 .Case("mips64el", Triple::mips64el)
350 .Case("r600", Triple::r600)
351 .Case("amdgcn", Triple::amdgcn)
352 .Case("hexagon", Triple::hexagon)
353 .Case("s390x", Triple::systemz)
354 .Case("sparc", Triple::sparc)
355 .Case("sparcel", Triple::sparcel)
356 .Cases("sparcv9", "sparc64", Triple::sparcv9)
357 .Case("tce", Triple::tce)
358 .Case("xcore", Triple::xcore)
359 .Case("nvptx", Triple::nvptx)
360 .Case("nvptx64", Triple::nvptx64)
361 .Case("le32", Triple::le32)
362 .Case("le64", Triple::le64)
363 .Case("amdil", Triple::amdil)
364 .Case("amdil64", Triple::amdil64)
365 .Case("hsail", Triple::hsail)
366 .Case("hsail64", Triple::hsail64)
367 .Case("spir", Triple::spir)
368 .Case("spir64", Triple::spir64)
369 .StartsWith("kalimba", Triple::kalimba)
370 .Case("shave", Triple::shave)
371 .Case("wasm32", Triple::wasm32)
372 .Case("wasm64", Triple::wasm64)
373 .Default(Triple::UnknownArch);
375 // Some architectures require special parsing logic just to compute the
377 if (AT == Triple::UnknownArch) {
378 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
379 ArchName.startswith("aarch64"))
380 return parseARMArch(ArchName);
381 if (ArchName.startswith("bpf"))
382 return parseBPFArch(ArchName);
388 static Triple::VendorType parseVendor(StringRef VendorName) {
389 return StringSwitch<Triple::VendorType>(VendorName)
390 .Case("apple", Triple::Apple)
391 .Case("pc", Triple::PC)
392 .Case("scei", Triple::SCEI)
393 .Case("bgp", Triple::BGP)
394 .Case("bgq", Triple::BGQ)
395 .Case("fsl", Triple::Freescale)
396 .Case("ibm", Triple::IBM)
397 .Case("img", Triple::ImaginationTechnologies)
398 .Case("mti", Triple::MipsTechnologies)
399 .Case("nvidia", Triple::NVIDIA)
400 .Case("csr", Triple::CSR)
401 .Default(Triple::UnknownVendor);
404 static Triple::OSType parseOS(StringRef OSName) {
405 return StringSwitch<Triple::OSType>(OSName)
406 .StartsWith("cloudabi", Triple::CloudABI)
407 .StartsWith("darwin", Triple::Darwin)
408 .StartsWith("dragonfly", Triple::DragonFly)
409 .StartsWith("freebsd", Triple::FreeBSD)
410 .StartsWith("ios", Triple::IOS)
411 .StartsWith("kfreebsd", Triple::KFreeBSD)
412 .StartsWith("linux", Triple::Linux)
413 .StartsWith("lv2", Triple::Lv2)
414 .StartsWith("macosx", Triple::MacOSX)
415 .StartsWith("netbsd", Triple::NetBSD)
416 .StartsWith("openbsd", Triple::OpenBSD)
417 .StartsWith("solaris", Triple::Solaris)
418 .StartsWith("win32", Triple::Win32)
419 .StartsWith("windows", Triple::Win32)
420 .StartsWith("haiku", Triple::Haiku)
421 .StartsWith("minix", Triple::Minix)
422 .StartsWith("rtems", Triple::RTEMS)
423 .StartsWith("nacl", Triple::NaCl)
424 .StartsWith("cnk", Triple::CNK)
425 .StartsWith("bitrig", Triple::Bitrig)
426 .StartsWith("aix", Triple::AIX)
427 .StartsWith("cuda", Triple::CUDA)
428 .StartsWith("nvcl", Triple::NVCL)
429 .StartsWith("amdhsa", Triple::AMDHSA)
430 .StartsWith("ps4", Triple::PS4)
431 .Default(Triple::UnknownOS);
434 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
435 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
436 .StartsWith("eabihf", Triple::EABIHF)
437 .StartsWith("eabi", Triple::EABI)
438 .StartsWith("gnueabihf", Triple::GNUEABIHF)
439 .StartsWith("gnueabi", Triple::GNUEABI)
440 .StartsWith("gnux32", Triple::GNUX32)
441 .StartsWith("code16", Triple::CODE16)
442 .StartsWith("gnu", Triple::GNU)
443 .StartsWith("android", Triple::Android)
444 .StartsWith("msvc", Triple::MSVC)
445 .StartsWith("itanium", Triple::Itanium)
446 .StartsWith("cygnus", Triple::Cygnus)
447 .StartsWith("amdopencl", Triple::AMDOpenCL)
448 .StartsWith("coreclr", Triple::CoreCLR)
449 .Default(Triple::UnknownEnvironment);
452 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
453 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
454 .EndsWith("coff", Triple::COFF)
455 .EndsWith("elf", Triple::ELF)
456 .EndsWith("macho", Triple::MachO)
457 .Default(Triple::UnknownObjectFormat);
460 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
461 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
463 // For now, this is the small part. Early return.
464 if (ARMSubArch.empty())
465 return StringSwitch<Triple::SubArchType>(SubArchName)
466 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
467 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
468 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
469 .Default(Triple::NoSubArch);
472 switch(ARM::parseArch(ARMSubArch)) {
474 return Triple::NoSubArch;
476 return Triple::ARMSubArch_v4t;
480 return Triple::ARMSubArch_v5;
481 case ARM::AK_ARMV5TE:
483 case ARM::AK_IWMMXT2:
485 case ARM::AK_ARMV5TEJ:
486 return Triple::ARMSubArch_v5te;
490 return Triple::ARMSubArch_v6;
492 case ARM::AK_ARMV6ZK:
493 case ARM::AK_ARMV6HL:
494 return Triple::ARMSubArch_v6k;
495 case ARM::AK_ARMV6T2:
496 return Triple::ARMSubArch_v6t2;
498 case ARM::AK_ARMV6SM:
499 return Triple::ARMSubArch_v6m;
504 case ARM::AK_ARMV7HL:
505 return Triple::ARMSubArch_v7;
507 return Triple::ARMSubArch_v7m;
509 return Triple::ARMSubArch_v7s;
510 case ARM::AK_ARMV7EM:
511 return Triple::ARMSubArch_v7em;
513 return Triple::ARMSubArch_v8;
514 case ARM::AK_ARMV8_1A:
515 return Triple::ARMSubArch_v8_1a;
517 return Triple::NoSubArch;
521 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
523 case Triple::UnknownObjectFormat: return "";
524 case Triple::COFF: return "coff";
525 case Triple::ELF: return "elf";
526 case Triple::MachO: return "macho";
528 llvm_unreachable("unknown object format type");
531 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
532 switch (T.getArch()) {
535 case Triple::hexagon:
539 case Triple::mips64el:
543 case Triple::sparcv9:
544 case Triple::systemz:
546 case Triple::ppc64le:
552 return Triple::MachO;
557 // Unknown for now, until an object format is specified.
558 return Triple::UnknownObjectFormat;
562 return Triple::MachO;
563 else if (T.isOSWindows())
568 /// \brief Construct a triple from the string representation provided.
570 /// This stores the string representation and parses the various pieces into
572 Triple::Triple(const Twine &Str)
574 Arch(parseArch(getArchName())),
575 SubArch(parseSubArch(getArchName())),
576 Vendor(parseVendor(getVendorName())),
577 OS(parseOS(getOSName())),
578 Environment(parseEnvironment(getEnvironmentName())),
579 ObjectFormat(parseFormat(getEnvironmentName())) {
580 if (ObjectFormat == Triple::UnknownObjectFormat)
581 ObjectFormat = getDefaultFormat(*this);
584 /// \brief Construct a triple from string representations of the architecture,
587 /// This joins each argument into a canonical string representation and parses
588 /// them into enum members. It leaves the environment unknown and omits it from
589 /// the string representation.
590 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
591 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
592 Arch(parseArch(ArchStr.str())),
593 SubArch(parseSubArch(ArchStr.str())),
594 Vendor(parseVendor(VendorStr.str())),
595 OS(parseOS(OSStr.str())),
596 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
597 ObjectFormat = getDefaultFormat(*this);
600 /// \brief Construct a triple from string representations of the architecture,
601 /// vendor, OS, and environment.
603 /// This joins each argument into a canonical string representation and parses
604 /// them into enum members.
605 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
606 const Twine &EnvironmentStr)
607 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
608 EnvironmentStr).str()),
609 Arch(parseArch(ArchStr.str())),
610 SubArch(parseSubArch(ArchStr.str())),
611 Vendor(parseVendor(VendorStr.str())),
612 OS(parseOS(OSStr.str())),
613 Environment(parseEnvironment(EnvironmentStr.str())),
614 ObjectFormat(parseFormat(EnvironmentStr.str())) {
615 if (ObjectFormat == Triple::UnknownObjectFormat)
616 ObjectFormat = getDefaultFormat(*this);
619 std::string Triple::normalize(StringRef Str) {
620 bool IsMinGW32 = false;
621 bool IsCygwin = false;
623 // Parse into components.
624 SmallVector<StringRef, 4> Components;
625 Str.split(Components, "-");
627 // If the first component corresponds to a known architecture, preferentially
628 // use it for the architecture. If the second component corresponds to a
629 // known vendor, preferentially use it for the vendor, etc. This avoids silly
630 // component movement when a component parses as (eg) both a valid arch and a
632 ArchType Arch = UnknownArch;
633 if (Components.size() > 0)
634 Arch = parseArch(Components[0]);
635 VendorType Vendor = UnknownVendor;
636 if (Components.size() > 1)
637 Vendor = parseVendor(Components[1]);
638 OSType OS = UnknownOS;
639 if (Components.size() > 2) {
640 OS = parseOS(Components[2]);
641 IsCygwin = Components[2].startswith("cygwin");
642 IsMinGW32 = Components[2].startswith("mingw");
644 EnvironmentType Environment = UnknownEnvironment;
645 if (Components.size() > 3)
646 Environment = parseEnvironment(Components[3]);
647 ObjectFormatType ObjectFormat = UnknownObjectFormat;
648 if (Components.size() > 4)
649 ObjectFormat = parseFormat(Components[4]);
651 // Note which components are already in their final position. These will not
654 Found[0] = Arch != UnknownArch;
655 Found[1] = Vendor != UnknownVendor;
656 Found[2] = OS != UnknownOS;
657 Found[3] = Environment != UnknownEnvironment;
659 // If they are not there already, permute the components into their canonical
660 // positions by seeing if they parse as a valid architecture, and if so moving
661 // the component to the architecture position etc.
662 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
664 continue; // Already in the canonical position.
666 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
667 // Do not reparse any components that already matched.
668 if (Idx < array_lengthof(Found) && Found[Idx])
671 // Does this component parse as valid for the target position?
673 StringRef Comp = Components[Idx];
675 default: llvm_unreachable("unexpected component type!");
677 Arch = parseArch(Comp);
678 Valid = Arch != UnknownArch;
681 Vendor = parseVendor(Comp);
682 Valid = Vendor != UnknownVendor;
686 IsCygwin = Comp.startswith("cygwin");
687 IsMinGW32 = Comp.startswith("mingw");
688 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
691 Environment = parseEnvironment(Comp);
692 Valid = Environment != UnknownEnvironment;
694 ObjectFormat = parseFormat(Comp);
695 Valid = ObjectFormat != UnknownObjectFormat;
700 continue; // Nope, try the next component.
702 // Move the component to the target position, pushing any non-fixed
703 // components that are in the way to the right. This tends to give
704 // good results in the common cases of a forgotten vendor component
705 // or a wrongly positioned environment.
707 // Insert left, pushing the existing components to the right. For
708 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
709 StringRef CurrentComponent(""); // The empty component.
710 // Replace the component we are moving with an empty component.
711 std::swap(CurrentComponent, Components[Idx]);
712 // Insert the component being moved at Pos, displacing any existing
713 // components to the right.
714 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
715 // Skip over any fixed components.
716 while (i < array_lengthof(Found) && Found[i])
718 // Place the component at the new position, getting the component
719 // that was at this position - it will be moved right.
720 std::swap(CurrentComponent, Components[i]);
722 } else if (Pos > Idx) {
723 // Push right by inserting empty components until the component at Idx
724 // reaches the target position Pos. For example, pc-a -> -pc-a when
725 // moving pc to the second position.
727 // Insert one empty component at Idx.
728 StringRef CurrentComponent(""); // The empty component.
729 for (unsigned i = Idx; i < Components.size();) {
730 // Place the component at the new position, getting the component
731 // that was at this position - it will be moved right.
732 std::swap(CurrentComponent, Components[i]);
733 // If it was placed on top of an empty component then we are done.
734 if (CurrentComponent.empty())
736 // Advance to the next component, skipping any fixed components.
737 while (++i < array_lengthof(Found) && Found[i])
740 // The last component was pushed off the end - append it.
741 if (!CurrentComponent.empty())
742 Components.push_back(CurrentComponent);
744 // Advance Idx to the component's new position.
745 while (++Idx < array_lengthof(Found) && Found[Idx])
747 } while (Idx < Pos); // Add more until the final position is reached.
749 assert(Pos < Components.size() && Components[Pos] == Comp &&
750 "Component moved wrong!");
756 // Special case logic goes here. At this point Arch, Vendor and OS have the
757 // correct values for the computed components.
758 std::string NormalizedEnvironment;
759 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
760 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
761 if (AndroidVersion.empty()) {
762 Components[3] = "android";
764 NormalizedEnvironment = Twine("android", AndroidVersion).str();
765 Components[3] = NormalizedEnvironment;
769 if (OS == Triple::Win32) {
770 Components.resize(4);
771 Components[2] = "windows";
772 if (Environment == UnknownEnvironment) {
773 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
774 Components[3] = "msvc";
776 Components[3] = getObjectFormatTypeName(ObjectFormat);
778 } else if (IsMinGW32) {
779 Components.resize(4);
780 Components[2] = "windows";
781 Components[3] = "gnu";
782 } else if (IsCygwin) {
783 Components.resize(4);
784 Components[2] = "windows";
785 Components[3] = "cygnus";
787 if (IsMinGW32 || IsCygwin ||
788 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
789 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
790 Components.resize(5);
791 Components[4] = getObjectFormatTypeName(ObjectFormat);
795 // Stick the corrected components back together to form the normalized string.
796 std::string Normalized;
797 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
798 if (i) Normalized += '-';
799 Normalized += Components[i];
804 StringRef Triple::getArchName() const {
805 return StringRef(Data).split('-').first; // Isolate first component
808 StringRef Triple::getVendorName() const {
809 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
810 return Tmp.split('-').first; // Isolate second component
813 StringRef Triple::getOSName() const {
814 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
815 Tmp = Tmp.split('-').second; // Strip second component
816 return Tmp.split('-').first; // Isolate third component
819 StringRef Triple::getEnvironmentName() const {
820 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
821 Tmp = Tmp.split('-').second; // Strip second component
822 return Tmp.split('-').second; // Strip third component
825 StringRef Triple::getOSAndEnvironmentName() const {
826 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
827 return Tmp.split('-').second; // Strip second component
830 static unsigned EatNumber(StringRef &Str) {
831 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
835 // Consume the leading digit.
836 Result = Result*10 + (Str[0] - '0');
840 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
845 static void parseVersionFromName(StringRef Name, unsigned &Major,
846 unsigned &Minor, unsigned &Micro) {
847 // Any unset version defaults to 0.
848 Major = Minor = Micro = 0;
850 // Parse up to three components.
851 unsigned *Components[3] = {&Major, &Minor, &Micro};
852 for (unsigned i = 0; i != 3; ++i) {
853 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
856 // Consume the leading number.
857 *Components[i] = EatNumber(Name);
859 // Consume the separator, if present.
860 if (Name.startswith("."))
861 Name = Name.substr(1);
865 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
866 unsigned &Micro) const {
867 StringRef EnvironmentName = getEnvironmentName();
868 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
869 if (EnvironmentName.startswith(EnvironmentTypeName))
870 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
872 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
875 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
876 unsigned &Micro) const {
877 StringRef OSName = getOSName();
878 // Assume that the OS portion of the triple starts with the canonical name.
879 StringRef OSTypeName = getOSTypeName(getOS());
880 if (OSName.startswith(OSTypeName))
881 OSName = OSName.substr(OSTypeName.size());
883 parseVersionFromName(OSName, Major, Minor, Micro);
886 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
887 unsigned &Micro) const {
888 getOSVersion(Major, Minor, Micro);
891 default: llvm_unreachable("unexpected OS for Darwin triple");
893 // Default to darwin8, i.e., MacOSX 10.4.
896 // Darwin version numbers are skewed from OS X versions.
913 // Ignore the version from the triple. This is only handled because the
914 // the clang driver combines OS X and IOS support into a common Darwin
915 // toolchain that wants to know the OS X version number even when targeting
925 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
926 unsigned &Micro) const {
928 default: llvm_unreachable("unexpected OS for Darwin triple");
931 // Ignore the version from the triple. This is only handled because the
932 // the clang driver combines OS X and IOS support into a common Darwin
933 // toolchain that wants to know the iOS version number even when targeting
940 getOSVersion(Major, Minor, Micro);
941 // Default to 5.0 (or 7.0 for arm64).
943 Major = (getArch() == aarch64) ? 7 : 5;
948 void Triple::setTriple(const Twine &Str) {
952 void Triple::setArch(ArchType Kind) {
953 setArchName(getArchTypeName(Kind));
956 void Triple::setVendor(VendorType Kind) {
957 setVendorName(getVendorTypeName(Kind));
960 void Triple::setOS(OSType Kind) {
961 setOSName(getOSTypeName(Kind));
964 void Triple::setEnvironment(EnvironmentType Kind) {
965 if (ObjectFormat == getDefaultFormat(*this))
966 return setEnvironmentName(getEnvironmentTypeName(Kind));
968 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
969 getObjectFormatTypeName(ObjectFormat)).str());
972 void Triple::setObjectFormat(ObjectFormatType Kind) {
973 if (Environment == UnknownEnvironment)
974 return setEnvironmentName(getObjectFormatTypeName(Kind));
976 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
977 getObjectFormatTypeName(Kind)).str());
980 void Triple::setArchName(StringRef Str) {
981 // Work around a miscompilation bug for Twines in gcc 4.0.3.
982 SmallString<64> Triple;
985 Triple += getVendorName();
987 Triple += getOSAndEnvironmentName();
991 void Triple::setVendorName(StringRef Str) {
992 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
995 void Triple::setOSName(StringRef Str) {
996 if (hasEnvironment())
997 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
998 "-" + getEnvironmentName());
1000 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1003 void Triple::setEnvironmentName(StringRef Str) {
1004 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1008 void Triple::setOSAndEnvironmentName(StringRef Str) {
1009 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1012 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1014 case llvm::Triple::UnknownArch:
1017 case llvm::Triple::msp430:
1020 case llvm::Triple::arm:
1021 case llvm::Triple::armeb:
1022 case llvm::Triple::hexagon:
1023 case llvm::Triple::le32:
1024 case llvm::Triple::mips:
1025 case llvm::Triple::mipsel:
1026 case llvm::Triple::nvptx:
1027 case llvm::Triple::ppc:
1028 case llvm::Triple::r600:
1029 case llvm::Triple::sparc:
1030 case llvm::Triple::sparcel:
1031 case llvm::Triple::tce:
1032 case llvm::Triple::thumb:
1033 case llvm::Triple::thumbeb:
1034 case llvm::Triple::x86:
1035 case llvm::Triple::xcore:
1036 case llvm::Triple::amdil:
1037 case llvm::Triple::hsail:
1038 case llvm::Triple::spir:
1039 case llvm::Triple::kalimba:
1040 case llvm::Triple::shave:
1041 case llvm::Triple::wasm32:
1044 case llvm::Triple::aarch64:
1045 case llvm::Triple::aarch64_be:
1046 case llvm::Triple::amdgcn:
1047 case llvm::Triple::bpfel:
1048 case llvm::Triple::bpfeb:
1049 case llvm::Triple::le64:
1050 case llvm::Triple::mips64:
1051 case llvm::Triple::mips64el:
1052 case llvm::Triple::nvptx64:
1053 case llvm::Triple::ppc64:
1054 case llvm::Triple::ppc64le:
1055 case llvm::Triple::sparcv9:
1056 case llvm::Triple::systemz:
1057 case llvm::Triple::x86_64:
1058 case llvm::Triple::amdil64:
1059 case llvm::Triple::hsail64:
1060 case llvm::Triple::spir64:
1061 case llvm::Triple::wasm64:
1064 llvm_unreachable("Invalid architecture value");
1067 bool Triple::isArch64Bit() const {
1068 return getArchPointerBitWidth(getArch()) == 64;
1071 bool Triple::isArch32Bit() const {
1072 return getArchPointerBitWidth(getArch()) == 32;
1075 bool Triple::isArch16Bit() const {
1076 return getArchPointerBitWidth(getArch()) == 16;
1079 Triple Triple::get32BitArchVariant() const {
1081 switch (getArch()) {
1082 case Triple::UnknownArch:
1083 case Triple::aarch64:
1084 case Triple::aarch64_be:
1085 case Triple::amdgcn:
1088 case Triple::msp430:
1089 case Triple::systemz:
1090 case Triple::ppc64le:
1091 T.setArch(UnknownArch);
1099 case Triple::hexagon:
1100 case Triple::kalimba:
1103 case Triple::mipsel:
1108 case Triple::sparcel:
1111 case Triple::thumbeb:
1115 case Triple::wasm32:
1119 case Triple::le64: T.setArch(Triple::le32); break;
1120 case Triple::mips64: T.setArch(Triple::mips); break;
1121 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1122 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1123 case Triple::ppc64: T.setArch(Triple::ppc); break;
1124 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1125 case Triple::x86_64: T.setArch(Triple::x86); break;
1126 case Triple::amdil64: T.setArch(Triple::amdil); break;
1127 case Triple::hsail64: T.setArch(Triple::hsail); break;
1128 case Triple::spir64: T.setArch(Triple::spir); break;
1129 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1134 Triple Triple::get64BitArchVariant() const {
1136 switch (getArch()) {
1137 case Triple::UnknownArch:
1140 case Triple::hexagon:
1141 case Triple::kalimba:
1142 case Triple::msp430:
1146 case Triple::thumbeb:
1148 case Triple::sparcel:
1150 T.setArch(UnknownArch);
1153 case Triple::aarch64:
1154 case Triple::aarch64_be:
1158 case Triple::amdil64:
1159 case Triple::amdgcn:
1160 case Triple::hsail64:
1161 case Triple::spir64:
1162 case Triple::mips64:
1163 case Triple::mips64el:
1164 case Triple::nvptx64:
1166 case Triple::ppc64le:
1167 case Triple::sparcv9:
1168 case Triple::systemz:
1169 case Triple::x86_64:
1170 case Triple::wasm64:
1174 case Triple::le32: T.setArch(Triple::le64); break;
1175 case Triple::mips: T.setArch(Triple::mips64); break;
1176 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1177 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1178 case Triple::ppc: T.setArch(Triple::ppc64); break;
1179 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1180 case Triple::x86: T.setArch(Triple::x86_64); break;
1181 case Triple::amdil: T.setArch(Triple::amdil64); break;
1182 case Triple::hsail: T.setArch(Triple::hsail64); break;
1183 case Triple::spir: T.setArch(Triple::spir64); break;
1184 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1189 Triple Triple::getBigEndianArchVariant() const {
1191 switch (getArch()) {
1192 case Triple::UnknownArch:
1193 case Triple::amdgcn:
1194 case Triple::amdil64:
1196 case Triple::hexagon:
1197 case Triple::hsail64:
1199 case Triple::kalimba:
1202 case Triple::msp430:
1203 case Triple::nvptx64:
1207 case Triple::spir64:
1209 case Triple::wasm32:
1210 case Triple::wasm64:
1212 case Triple::x86_64:
1215 // ARM is intentionally unsupported here, changing the architecture would
1216 // drop any arch suffixes.
1219 T.setArch(UnknownArch);
1222 case Triple::aarch64_be:
1225 case Triple::mips64:
1230 case Triple::sparcv9:
1231 case Triple::systemz:
1233 case Triple::thumbeb:
1234 // Already big endian.
1237 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1238 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1239 case Triple::mips64el:T.setArch(Triple::mips64); break;
1240 case Triple::mipsel: T.setArch(Triple::mips); break;
1241 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1242 case Triple::sparcel: T.setArch(Triple::sparc); break;
1247 Triple Triple::getLittleEndianArchVariant() const {
1249 switch (getArch()) {
1250 case Triple::UnknownArch:
1252 case Triple::sparcv9:
1253 case Triple::systemz:
1256 // ARM is intentionally unsupported here, changing the architecture would
1257 // drop any arch suffixes.
1259 case Triple::thumbeb:
1260 T.setArch(UnknownArch);
1263 case Triple::aarch64:
1264 case Triple::amdgcn:
1265 case Triple::amdil64:
1269 case Triple::hexagon:
1270 case Triple::hsail64:
1272 case Triple::kalimba:
1275 case Triple::mips64el:
1276 case Triple::mipsel:
1277 case Triple::msp430:
1278 case Triple::nvptx64:
1280 case Triple::ppc64le:
1283 case Triple::sparcel:
1284 case Triple::spir64:
1287 case Triple::wasm32:
1288 case Triple::wasm64:
1290 case Triple::x86_64:
1292 // Already little endian.
1295 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1296 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1297 case Triple::mips64: T.setArch(Triple::mips64el); break;
1298 case Triple::mips: T.setArch(Triple::mipsel); break;
1299 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1300 case Triple::sparc: T.setArch(Triple::sparcel); break;
1305 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1307 MArch = getArchName();
1308 MArch = ARM::getCanonicalArchName(MArch);
1310 // Some defaults are forced.
1312 case llvm::Triple::FreeBSD:
1313 case llvm::Triple::NetBSD:
1314 if (!MArch.empty() && MArch == "v6")
1315 return "arm1176jzf-s";
1317 case llvm::Triple::Win32:
1318 // FIXME: this is invalid for WindowsCE
1327 StringRef CPU = ARM::getDefaultCPU(MArch);
1331 // If no specific architecture version is requested, return the minimum CPU
1332 // required by the OS and environment.
1334 case llvm::Triple::NetBSD:
1335 switch (getEnvironment()) {
1336 case llvm::Triple::GNUEABIHF:
1337 case llvm::Triple::GNUEABI:
1338 case llvm::Triple::EABIHF:
1339 case llvm::Triple::EABI:
1340 return "arm926ej-s";
1344 case llvm::Triple::NaCl:
1347 switch (getEnvironment()) {
1348 case llvm::Triple::EABIHF:
1349 case llvm::Triple::GNUEABIHF:
1350 return "arm1176jzf-s";
1356 llvm_unreachable("invalid arch name");