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";
147 case Myriad: return "myriad";
150 llvm_unreachable("Invalid VendorType!");
153 const char *Triple::getOSTypeName(OSType Kind) {
155 case UnknownOS: return "unknown";
157 case CloudABI: return "cloudabi";
158 case Darwin: return "darwin";
159 case DragonFly: return "dragonfly";
160 case FreeBSD: return "freebsd";
161 case IOS: return "ios";
162 case KFreeBSD: return "kfreebsd";
163 case Linux: return "linux";
164 case Lv2: return "lv2";
165 case MacOSX: return "macosx";
166 case NetBSD: return "netbsd";
167 case OpenBSD: return "openbsd";
168 case Solaris: return "solaris";
169 case Win32: return "windows";
170 case Haiku: return "haiku";
171 case Minix: return "minix";
172 case RTEMS: return "rtems";
173 case NaCl: return "nacl";
174 case CNK: return "cnk";
175 case Bitrig: return "bitrig";
176 case AIX: return "aix";
177 case CUDA: return "cuda";
178 case NVCL: return "nvcl";
179 case AMDHSA: return "amdhsa";
180 case PS4: return "ps4";
183 llvm_unreachable("Invalid OSType");
186 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
188 case UnknownEnvironment: return "unknown";
189 case GNU: return "gnu";
190 case GNUEABIHF: return "gnueabihf";
191 case GNUEABI: return "gnueabi";
192 case GNUX32: return "gnux32";
193 case CODE16: return "code16";
194 case EABI: return "eabi";
195 case EABIHF: return "eabihf";
196 case Android: return "android";
197 case MSVC: return "msvc";
198 case Itanium: return "itanium";
199 case Cygnus: return "cygnus";
200 case AMDOpenCL: return "amdopencl";
201 case CoreCLR: return "coreclr";
204 llvm_unreachable("Invalid EnvironmentType!");
207 static Triple::ArchType parseBPFArch(StringRef ArchName) {
208 if (ArchName.equals("bpf")) {
209 if (sys::IsLittleEndianHost)
210 return Triple::bpfel;
212 return Triple::bpfeb;
213 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
214 return Triple::bpfeb;
215 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
216 return Triple::bpfel;
218 return Triple::UnknownArch;
222 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
223 Triple::ArchType BPFArch(parseBPFArch(Name));
224 return StringSwitch<Triple::ArchType>(Name)
225 .Case("aarch64", aarch64)
226 .Case("aarch64_be", aarch64_be)
227 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
229 .Case("armeb", armeb)
230 .StartsWith("bpf", BPFArch)
232 .Case("mipsel", mipsel)
233 .Case("mips64", mips64)
234 .Case("mips64el", mips64el)
235 .Case("msp430", msp430)
236 .Case("ppc64", ppc64)
239 .Case("ppc64le", ppc64le)
241 .Case("amdgcn", amdgcn)
242 .Case("hexagon", hexagon)
243 .Case("sparc", sparc)
244 .Case("sparcel", sparcel)
245 .Case("sparcv9", sparcv9)
246 .Case("systemz", systemz)
248 .Case("thumb", thumb)
249 .Case("thumbeb", thumbeb)
251 .Case("x86-64", x86_64)
252 .Case("xcore", xcore)
253 .Case("nvptx", nvptx)
254 .Case("nvptx64", nvptx64)
257 .Case("amdil", amdil)
258 .Case("amdil64", amdil64)
259 .Case("hsail", hsail)
260 .Case("hsail64", hsail64)
262 .Case("spir64", spir64)
263 .Case("kalimba", kalimba)
264 .Case("shave", shave)
265 .Case("wasm32", wasm32)
266 .Case("wasm64", wasm64)
267 .Default(UnknownArch);
270 static Triple::ArchType parseARMArch(StringRef ArchName) {
271 unsigned ISA = ARM::parseArchISA(ArchName);
272 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
274 Triple::ArchType arch = Triple::UnknownArch;
276 case ARM::EK_LITTLE: {
282 arch = Triple::thumb;
284 case ARM::IK_AARCH64:
285 arch = Triple::aarch64;
293 arch = Triple::armeb;
296 arch = Triple::thumbeb;
298 case ARM::IK_AARCH64:
299 arch = Triple::aarch64_be;
306 ArchName = ARM::getCanonicalArchName(ArchName);
307 if (ArchName.empty())
308 return Triple::UnknownArch;
310 // Thumb only exists in v4+
311 if (ISA == ARM::IK_THUMB &&
312 (ArchName.startswith("v2") || ArchName.startswith("v3")))
313 return Triple::UnknownArch;
315 // Thumb only for v6m
316 unsigned Profile = ARM::parseArchProfile(ArchName);
317 unsigned Version = ARM::parseArchVersion(ArchName);
318 if (Profile == ARM::PK_M && Version == 6) {
319 if (ENDIAN == ARM::EK_BIG)
320 return Triple::thumbeb;
322 return Triple::thumb;
328 static Triple::ArchType parseArch(StringRef ArchName) {
329 auto AT = StringSwitch<Triple::ArchType>(ArchName)
330 .Cases("i386", "i486", "i586", "i686", Triple::x86)
331 // FIXME: Do we need to support these?
332 .Cases("i786", "i886", "i986", Triple::x86)
333 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
334 .Case("powerpc", Triple::ppc)
335 .Cases("powerpc64", "ppu", Triple::ppc64)
336 .Case("powerpc64le", Triple::ppc64le)
337 .Case("xscale", Triple::arm)
338 .Case("xscaleeb", Triple::armeb)
339 .Case("aarch64", Triple::aarch64)
340 .Case("aarch64_be", Triple::aarch64_be)
341 .Case("arm64", Triple::aarch64)
342 .Case("arm", Triple::arm)
343 .Case("armeb", Triple::armeb)
344 .Case("thumb", Triple::thumb)
345 .Case("thumbeb", Triple::thumbeb)
346 .Case("msp430", Triple::msp430)
347 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
348 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
349 .Cases("mips64", "mips64eb", Triple::mips64)
350 .Case("mips64el", Triple::mips64el)
351 .Case("r600", Triple::r600)
352 .Case("amdgcn", Triple::amdgcn)
353 .Case("hexagon", Triple::hexagon)
354 .Case("s390x", Triple::systemz)
355 .Case("sparc", Triple::sparc)
356 .Case("sparcel", Triple::sparcel)
357 .Cases("sparcv9", "sparc64", Triple::sparcv9)
358 .Case("tce", Triple::tce)
359 .Case("xcore", Triple::xcore)
360 .Case("nvptx", Triple::nvptx)
361 .Case("nvptx64", Triple::nvptx64)
362 .Case("le32", Triple::le32)
363 .Case("le64", Triple::le64)
364 .Case("amdil", Triple::amdil)
365 .Case("amdil64", Triple::amdil64)
366 .Case("hsail", Triple::hsail)
367 .Case("hsail64", Triple::hsail64)
368 .Case("spir", Triple::spir)
369 .Case("spir64", Triple::spir64)
370 .StartsWith("kalimba", Triple::kalimba)
371 .Case("shave", Triple::shave)
372 .Case("wasm32", Triple::wasm32)
373 .Case("wasm64", Triple::wasm64)
374 .Default(Triple::UnknownArch);
376 // Some architectures require special parsing logic just to compute the
378 if (AT == Triple::UnknownArch) {
379 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
380 ArchName.startswith("aarch64"))
381 return parseARMArch(ArchName);
382 if (ArchName.startswith("bpf"))
383 return parseBPFArch(ArchName);
389 static Triple::VendorType parseVendor(StringRef VendorName) {
390 return StringSwitch<Triple::VendorType>(VendorName)
391 .Case("apple", Triple::Apple)
392 .Case("pc", Triple::PC)
393 .Case("scei", Triple::SCEI)
394 .Case("bgp", Triple::BGP)
395 .Case("bgq", Triple::BGQ)
396 .Case("fsl", Triple::Freescale)
397 .Case("ibm", Triple::IBM)
398 .Case("img", Triple::ImaginationTechnologies)
399 .Case("mti", Triple::MipsTechnologies)
400 .Case("nvidia", Triple::NVIDIA)
401 .Case("csr", Triple::CSR)
402 .Case("myriad", Triple::Myriad)
403 .Default(Triple::UnknownVendor);
406 static Triple::OSType parseOS(StringRef OSName) {
407 return StringSwitch<Triple::OSType>(OSName)
408 .StartsWith("cloudabi", Triple::CloudABI)
409 .StartsWith("darwin", Triple::Darwin)
410 .StartsWith("dragonfly", Triple::DragonFly)
411 .StartsWith("freebsd", Triple::FreeBSD)
412 .StartsWith("ios", Triple::IOS)
413 .StartsWith("kfreebsd", Triple::KFreeBSD)
414 .StartsWith("linux", Triple::Linux)
415 .StartsWith("lv2", Triple::Lv2)
416 .StartsWith("macosx", Triple::MacOSX)
417 .StartsWith("netbsd", Triple::NetBSD)
418 .StartsWith("openbsd", Triple::OpenBSD)
419 .StartsWith("solaris", Triple::Solaris)
420 .StartsWith("win32", Triple::Win32)
421 .StartsWith("windows", Triple::Win32)
422 .StartsWith("haiku", Triple::Haiku)
423 .StartsWith("minix", Triple::Minix)
424 .StartsWith("rtems", Triple::RTEMS)
425 .StartsWith("nacl", Triple::NaCl)
426 .StartsWith("cnk", Triple::CNK)
427 .StartsWith("bitrig", Triple::Bitrig)
428 .StartsWith("aix", Triple::AIX)
429 .StartsWith("cuda", Triple::CUDA)
430 .StartsWith("nvcl", Triple::NVCL)
431 .StartsWith("amdhsa", Triple::AMDHSA)
432 .StartsWith("ps4", Triple::PS4)
433 .Default(Triple::UnknownOS);
436 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
437 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
438 .StartsWith("eabihf", Triple::EABIHF)
439 .StartsWith("eabi", Triple::EABI)
440 .StartsWith("gnueabihf", Triple::GNUEABIHF)
441 .StartsWith("gnueabi", Triple::GNUEABI)
442 .StartsWith("gnux32", Triple::GNUX32)
443 .StartsWith("code16", Triple::CODE16)
444 .StartsWith("gnu", Triple::GNU)
445 .StartsWith("android", Triple::Android)
446 .StartsWith("msvc", Triple::MSVC)
447 .StartsWith("itanium", Triple::Itanium)
448 .StartsWith("cygnus", Triple::Cygnus)
449 .StartsWith("amdopencl", Triple::AMDOpenCL)
450 .StartsWith("coreclr", Triple::CoreCLR)
451 .Default(Triple::UnknownEnvironment);
454 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
455 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
456 .EndsWith("coff", Triple::COFF)
457 .EndsWith("elf", Triple::ELF)
458 .EndsWith("macho", Triple::MachO)
459 .Default(Triple::UnknownObjectFormat);
462 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
463 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
465 // For now, this is the small part. Early return.
466 if (ARMSubArch.empty())
467 return StringSwitch<Triple::SubArchType>(SubArchName)
468 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
469 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
470 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
471 .Default(Triple::NoSubArch);
474 switch(ARM::parseArch(ARMSubArch)) {
476 return Triple::NoSubArch;
478 return Triple::ARMSubArch_v4t;
482 return Triple::ARMSubArch_v5;
483 case ARM::AK_ARMV5TE:
485 case ARM::AK_IWMMXT2:
487 case ARM::AK_ARMV5TEJ:
488 return Triple::ARMSubArch_v5te;
492 return Triple::ARMSubArch_v6;
494 case ARM::AK_ARMV6ZK:
495 case ARM::AK_ARMV6HL:
496 return Triple::ARMSubArch_v6k;
497 case ARM::AK_ARMV6T2:
498 return Triple::ARMSubArch_v6t2;
500 case ARM::AK_ARMV6SM:
501 return Triple::ARMSubArch_v6m;
506 case ARM::AK_ARMV7HL:
507 return Triple::ARMSubArch_v7;
509 return Triple::ARMSubArch_v7m;
511 return Triple::ARMSubArch_v7s;
512 case ARM::AK_ARMV7EM:
513 return Triple::ARMSubArch_v7em;
515 return Triple::ARMSubArch_v8;
516 case ARM::AK_ARMV8_1A:
517 return Triple::ARMSubArch_v8_1a;
519 return Triple::NoSubArch;
523 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
525 case Triple::UnknownObjectFormat: return "";
526 case Triple::COFF: return "coff";
527 case Triple::ELF: return "elf";
528 case Triple::MachO: return "macho";
530 llvm_unreachable("unknown object format type");
533 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
534 switch (T.getArch()) {
537 case Triple::hexagon:
541 case Triple::mips64el:
545 case Triple::sparcv9:
546 case Triple::systemz:
548 case Triple::ppc64le:
554 return Triple::MachO;
559 // Unknown for now, until an object format is specified.
560 return Triple::UnknownObjectFormat;
564 return Triple::MachO;
565 else if (T.isOSWindows())
570 /// \brief Construct a triple from the string representation provided.
572 /// This stores the string representation and parses the various pieces into
574 Triple::Triple(const Twine &Str)
576 Arch(parseArch(getArchName())),
577 SubArch(parseSubArch(getArchName())),
578 Vendor(parseVendor(getVendorName())),
579 OS(parseOS(getOSName())),
580 Environment(parseEnvironment(getEnvironmentName())),
581 ObjectFormat(parseFormat(getEnvironmentName())) {
582 if (ObjectFormat == Triple::UnknownObjectFormat)
583 ObjectFormat = getDefaultFormat(*this);
586 /// \brief Construct a triple from string representations of the architecture,
589 /// This joins each argument into a canonical string representation and parses
590 /// them into enum members. It leaves the environment unknown and omits it from
591 /// the string representation.
592 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
593 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
594 Arch(parseArch(ArchStr.str())),
595 SubArch(parseSubArch(ArchStr.str())),
596 Vendor(parseVendor(VendorStr.str())),
597 OS(parseOS(OSStr.str())),
598 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
599 ObjectFormat = getDefaultFormat(*this);
602 /// \brief Construct a triple from string representations of the architecture,
603 /// vendor, OS, and environment.
605 /// This joins each argument into a canonical string representation and parses
606 /// them into enum members.
607 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
608 const Twine &EnvironmentStr)
609 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
610 EnvironmentStr).str()),
611 Arch(parseArch(ArchStr.str())),
612 SubArch(parseSubArch(ArchStr.str())),
613 Vendor(parseVendor(VendorStr.str())),
614 OS(parseOS(OSStr.str())),
615 Environment(parseEnvironment(EnvironmentStr.str())),
616 ObjectFormat(parseFormat(EnvironmentStr.str())) {
617 if (ObjectFormat == Triple::UnknownObjectFormat)
618 ObjectFormat = getDefaultFormat(*this);
621 std::string Triple::normalize(StringRef Str) {
622 bool IsMinGW32 = false;
623 bool IsCygwin = false;
625 // Parse into components.
626 SmallVector<StringRef, 4> Components;
627 Str.split(Components, "-");
629 // If the first component corresponds to a known architecture, preferentially
630 // use it for the architecture. If the second component corresponds to a
631 // known vendor, preferentially use it for the vendor, etc. This avoids silly
632 // component movement when a component parses as (eg) both a valid arch and a
634 ArchType Arch = UnknownArch;
635 if (Components.size() > 0)
636 Arch = parseArch(Components[0]);
637 VendorType Vendor = UnknownVendor;
638 if (Components.size() > 1)
639 Vendor = parseVendor(Components[1]);
640 OSType OS = UnknownOS;
641 if (Components.size() > 2) {
642 OS = parseOS(Components[2]);
643 IsCygwin = Components[2].startswith("cygwin");
644 IsMinGW32 = Components[2].startswith("mingw");
646 EnvironmentType Environment = UnknownEnvironment;
647 if (Components.size() > 3)
648 Environment = parseEnvironment(Components[3]);
649 ObjectFormatType ObjectFormat = UnknownObjectFormat;
650 if (Components.size() > 4)
651 ObjectFormat = parseFormat(Components[4]);
653 // Note which components are already in their final position. These will not
656 Found[0] = Arch != UnknownArch;
657 Found[1] = Vendor != UnknownVendor;
658 Found[2] = OS != UnknownOS;
659 Found[3] = Environment != UnknownEnvironment;
661 // If they are not there already, permute the components into their canonical
662 // positions by seeing if they parse as a valid architecture, and if so moving
663 // the component to the architecture position etc.
664 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
666 continue; // Already in the canonical position.
668 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
669 // Do not reparse any components that already matched.
670 if (Idx < array_lengthof(Found) && Found[Idx])
673 // Does this component parse as valid for the target position?
675 StringRef Comp = Components[Idx];
677 default: llvm_unreachable("unexpected component type!");
679 Arch = parseArch(Comp);
680 Valid = Arch != UnknownArch;
683 Vendor = parseVendor(Comp);
684 Valid = Vendor != UnknownVendor;
688 IsCygwin = Comp.startswith("cygwin");
689 IsMinGW32 = Comp.startswith("mingw");
690 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
693 Environment = parseEnvironment(Comp);
694 Valid = Environment != UnknownEnvironment;
696 ObjectFormat = parseFormat(Comp);
697 Valid = ObjectFormat != UnknownObjectFormat;
702 continue; // Nope, try the next component.
704 // Move the component to the target position, pushing any non-fixed
705 // components that are in the way to the right. This tends to give
706 // good results in the common cases of a forgotten vendor component
707 // or a wrongly positioned environment.
709 // Insert left, pushing the existing components to the right. For
710 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
711 StringRef CurrentComponent(""); // The empty component.
712 // Replace the component we are moving with an empty component.
713 std::swap(CurrentComponent, Components[Idx]);
714 // Insert the component being moved at Pos, displacing any existing
715 // components to the right.
716 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
717 // Skip over any fixed components.
718 while (i < array_lengthof(Found) && Found[i])
720 // Place the component at the new position, getting the component
721 // that was at this position - it will be moved right.
722 std::swap(CurrentComponent, Components[i]);
724 } else if (Pos > Idx) {
725 // Push right by inserting empty components until the component at Idx
726 // reaches the target position Pos. For example, pc-a -> -pc-a when
727 // moving pc to the second position.
729 // Insert one empty component at Idx.
730 StringRef CurrentComponent(""); // The empty component.
731 for (unsigned i = Idx; i < Components.size();) {
732 // Place the component at the new position, getting the component
733 // that was at this position - it will be moved right.
734 std::swap(CurrentComponent, Components[i]);
735 // If it was placed on top of an empty component then we are done.
736 if (CurrentComponent.empty())
738 // Advance to the next component, skipping any fixed components.
739 while (++i < array_lengthof(Found) && Found[i])
742 // The last component was pushed off the end - append it.
743 if (!CurrentComponent.empty())
744 Components.push_back(CurrentComponent);
746 // Advance Idx to the component's new position.
747 while (++Idx < array_lengthof(Found) && Found[Idx])
749 } while (Idx < Pos); // Add more until the final position is reached.
751 assert(Pos < Components.size() && Components[Pos] == Comp &&
752 "Component moved wrong!");
758 // Special case logic goes here. At this point Arch, Vendor and OS have the
759 // correct values for the computed components.
760 std::string NormalizedEnvironment;
761 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
762 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
763 if (AndroidVersion.empty()) {
764 Components[3] = "android";
766 NormalizedEnvironment = Twine("android", AndroidVersion).str();
767 Components[3] = NormalizedEnvironment;
771 if (OS == Triple::Win32) {
772 Components.resize(4);
773 Components[2] = "windows";
774 if (Environment == UnknownEnvironment) {
775 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
776 Components[3] = "msvc";
778 Components[3] = getObjectFormatTypeName(ObjectFormat);
780 } else if (IsMinGW32) {
781 Components.resize(4);
782 Components[2] = "windows";
783 Components[3] = "gnu";
784 } else if (IsCygwin) {
785 Components.resize(4);
786 Components[2] = "windows";
787 Components[3] = "cygnus";
789 if (IsMinGW32 || IsCygwin ||
790 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
791 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
792 Components.resize(5);
793 Components[4] = getObjectFormatTypeName(ObjectFormat);
797 // Stick the corrected components back together to form the normalized string.
798 std::string Normalized;
799 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
800 if (i) Normalized += '-';
801 Normalized += Components[i];
806 StringRef Triple::getArchName() const {
807 return StringRef(Data).split('-').first; // Isolate first component
810 StringRef Triple::getVendorName() const {
811 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
812 return Tmp.split('-').first; // Isolate second component
815 StringRef Triple::getOSName() const {
816 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
817 Tmp = Tmp.split('-').second; // Strip second component
818 return Tmp.split('-').first; // Isolate third component
821 StringRef Triple::getEnvironmentName() const {
822 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
823 Tmp = Tmp.split('-').second; // Strip second component
824 return Tmp.split('-').second; // Strip third component
827 StringRef Triple::getOSAndEnvironmentName() const {
828 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
829 return Tmp.split('-').second; // Strip second component
832 static unsigned EatNumber(StringRef &Str) {
833 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
837 // Consume the leading digit.
838 Result = Result*10 + (Str[0] - '0');
842 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
847 static void parseVersionFromName(StringRef Name, unsigned &Major,
848 unsigned &Minor, unsigned &Micro) {
849 // Any unset version defaults to 0.
850 Major = Minor = Micro = 0;
852 // Parse up to three components.
853 unsigned *Components[3] = {&Major, &Minor, &Micro};
854 for (unsigned i = 0; i != 3; ++i) {
855 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
858 // Consume the leading number.
859 *Components[i] = EatNumber(Name);
861 // Consume the separator, if present.
862 if (Name.startswith("."))
863 Name = Name.substr(1);
867 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
868 unsigned &Micro) const {
869 StringRef EnvironmentName = getEnvironmentName();
870 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
871 if (EnvironmentName.startswith(EnvironmentTypeName))
872 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
874 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
877 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
878 unsigned &Micro) const {
879 StringRef OSName = getOSName();
880 // Assume that the OS portion of the triple starts with the canonical name.
881 StringRef OSTypeName = getOSTypeName(getOS());
882 if (OSName.startswith(OSTypeName))
883 OSName = OSName.substr(OSTypeName.size());
885 parseVersionFromName(OSName, Major, Minor, Micro);
888 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
889 unsigned &Micro) const {
890 getOSVersion(Major, Minor, Micro);
893 default: llvm_unreachable("unexpected OS for Darwin triple");
895 // Default to darwin8, i.e., MacOSX 10.4.
898 // Darwin version numbers are skewed from OS X versions.
915 // Ignore the version from the triple. This is only handled because the
916 // the clang driver combines OS X and IOS support into a common Darwin
917 // toolchain that wants to know the OS X version number even when targeting
927 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
928 unsigned &Micro) const {
930 default: llvm_unreachable("unexpected OS for Darwin triple");
933 // Ignore the version from the triple. This is only handled because the
934 // the clang driver combines OS X and IOS support into a common Darwin
935 // toolchain that wants to know the iOS version number even when targeting
942 getOSVersion(Major, Minor, Micro);
943 // Default to 5.0 (or 7.0 for arm64).
945 Major = (getArch() == aarch64) ? 7 : 5;
950 void Triple::setTriple(const Twine &Str) {
954 void Triple::setArch(ArchType Kind) {
955 setArchName(getArchTypeName(Kind));
958 void Triple::setVendor(VendorType Kind) {
959 setVendorName(getVendorTypeName(Kind));
962 void Triple::setOS(OSType Kind) {
963 setOSName(getOSTypeName(Kind));
966 void Triple::setEnvironment(EnvironmentType Kind) {
967 if (ObjectFormat == getDefaultFormat(*this))
968 return setEnvironmentName(getEnvironmentTypeName(Kind));
970 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
971 getObjectFormatTypeName(ObjectFormat)).str());
974 void Triple::setObjectFormat(ObjectFormatType Kind) {
975 if (Environment == UnknownEnvironment)
976 return setEnvironmentName(getObjectFormatTypeName(Kind));
978 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
979 getObjectFormatTypeName(Kind)).str());
982 void Triple::setArchName(StringRef Str) {
983 // Work around a miscompilation bug for Twines in gcc 4.0.3.
984 SmallString<64> Triple;
987 Triple += getVendorName();
989 Triple += getOSAndEnvironmentName();
993 void Triple::setVendorName(StringRef Str) {
994 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
997 void Triple::setOSName(StringRef Str) {
998 if (hasEnvironment())
999 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1000 "-" + getEnvironmentName());
1002 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1005 void Triple::setEnvironmentName(StringRef Str) {
1006 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1010 void Triple::setOSAndEnvironmentName(StringRef Str) {
1011 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1014 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1016 case llvm::Triple::UnknownArch:
1019 case llvm::Triple::msp430:
1022 case llvm::Triple::arm:
1023 case llvm::Triple::armeb:
1024 case llvm::Triple::hexagon:
1025 case llvm::Triple::le32:
1026 case llvm::Triple::mips:
1027 case llvm::Triple::mipsel:
1028 case llvm::Triple::nvptx:
1029 case llvm::Triple::ppc:
1030 case llvm::Triple::r600:
1031 case llvm::Triple::sparc:
1032 case llvm::Triple::sparcel:
1033 case llvm::Triple::tce:
1034 case llvm::Triple::thumb:
1035 case llvm::Triple::thumbeb:
1036 case llvm::Triple::x86:
1037 case llvm::Triple::xcore:
1038 case llvm::Triple::amdil:
1039 case llvm::Triple::hsail:
1040 case llvm::Triple::spir:
1041 case llvm::Triple::kalimba:
1042 case llvm::Triple::shave:
1043 case llvm::Triple::wasm32:
1046 case llvm::Triple::aarch64:
1047 case llvm::Triple::aarch64_be:
1048 case llvm::Triple::amdgcn:
1049 case llvm::Triple::bpfel:
1050 case llvm::Triple::bpfeb:
1051 case llvm::Triple::le64:
1052 case llvm::Triple::mips64:
1053 case llvm::Triple::mips64el:
1054 case llvm::Triple::nvptx64:
1055 case llvm::Triple::ppc64:
1056 case llvm::Triple::ppc64le:
1057 case llvm::Triple::sparcv9:
1058 case llvm::Triple::systemz:
1059 case llvm::Triple::x86_64:
1060 case llvm::Triple::amdil64:
1061 case llvm::Triple::hsail64:
1062 case llvm::Triple::spir64:
1063 case llvm::Triple::wasm64:
1066 llvm_unreachable("Invalid architecture value");
1069 bool Triple::isArch64Bit() const {
1070 return getArchPointerBitWidth(getArch()) == 64;
1073 bool Triple::isArch32Bit() const {
1074 return getArchPointerBitWidth(getArch()) == 32;
1077 bool Triple::isArch16Bit() const {
1078 return getArchPointerBitWidth(getArch()) == 16;
1081 Triple Triple::get32BitArchVariant() const {
1083 switch (getArch()) {
1084 case Triple::UnknownArch:
1085 case Triple::aarch64:
1086 case Triple::aarch64_be:
1087 case Triple::amdgcn:
1090 case Triple::msp430:
1091 case Triple::systemz:
1092 case Triple::ppc64le:
1093 T.setArch(UnknownArch);
1101 case Triple::hexagon:
1102 case Triple::kalimba:
1105 case Triple::mipsel:
1110 case Triple::sparcel:
1113 case Triple::thumbeb:
1117 case Triple::wasm32:
1121 case Triple::le64: T.setArch(Triple::le32); break;
1122 case Triple::mips64: T.setArch(Triple::mips); break;
1123 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1124 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1125 case Triple::ppc64: T.setArch(Triple::ppc); break;
1126 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1127 case Triple::x86_64: T.setArch(Triple::x86); break;
1128 case Triple::amdil64: T.setArch(Triple::amdil); break;
1129 case Triple::hsail64: T.setArch(Triple::hsail); break;
1130 case Triple::spir64: T.setArch(Triple::spir); break;
1131 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1136 Triple Triple::get64BitArchVariant() const {
1138 switch (getArch()) {
1139 case Triple::UnknownArch:
1142 case Triple::hexagon:
1143 case Triple::kalimba:
1144 case Triple::msp430:
1148 case Triple::thumbeb:
1150 case Triple::sparcel:
1152 T.setArch(UnknownArch);
1155 case Triple::aarch64:
1156 case Triple::aarch64_be:
1160 case Triple::amdil64:
1161 case Triple::amdgcn:
1162 case Triple::hsail64:
1163 case Triple::spir64:
1164 case Triple::mips64:
1165 case Triple::mips64el:
1166 case Triple::nvptx64:
1168 case Triple::ppc64le:
1169 case Triple::sparcv9:
1170 case Triple::systemz:
1171 case Triple::x86_64:
1172 case Triple::wasm64:
1176 case Triple::le32: T.setArch(Triple::le64); break;
1177 case Triple::mips: T.setArch(Triple::mips64); break;
1178 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1179 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1180 case Triple::ppc: T.setArch(Triple::ppc64); break;
1181 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1182 case Triple::x86: T.setArch(Triple::x86_64); break;
1183 case Triple::amdil: T.setArch(Triple::amdil64); break;
1184 case Triple::hsail: T.setArch(Triple::hsail64); break;
1185 case Triple::spir: T.setArch(Triple::spir64); break;
1186 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1191 Triple Triple::getBigEndianArchVariant() const {
1193 switch (getArch()) {
1194 case Triple::UnknownArch:
1195 case Triple::amdgcn:
1196 case Triple::amdil64:
1198 case Triple::hexagon:
1199 case Triple::hsail64:
1201 case Triple::kalimba:
1204 case Triple::msp430:
1205 case Triple::nvptx64:
1209 case Triple::spir64:
1211 case Triple::wasm32:
1212 case Triple::wasm64:
1214 case Triple::x86_64:
1217 // ARM is intentionally unsupported here, changing the architecture would
1218 // drop any arch suffixes.
1221 T.setArch(UnknownArch);
1224 case Triple::aarch64_be:
1227 case Triple::mips64:
1232 case Triple::sparcv9:
1233 case Triple::systemz:
1235 case Triple::thumbeb:
1236 // Already big endian.
1239 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1240 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1241 case Triple::mips64el:T.setArch(Triple::mips64); break;
1242 case Triple::mipsel: T.setArch(Triple::mips); break;
1243 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1244 case Triple::sparcel: T.setArch(Triple::sparc); break;
1249 Triple Triple::getLittleEndianArchVariant() const {
1251 switch (getArch()) {
1252 case Triple::UnknownArch:
1254 case Triple::sparcv9:
1255 case Triple::systemz:
1258 // ARM is intentionally unsupported here, changing the architecture would
1259 // drop any arch suffixes.
1261 case Triple::thumbeb:
1262 T.setArch(UnknownArch);
1265 case Triple::aarch64:
1266 case Triple::amdgcn:
1267 case Triple::amdil64:
1271 case Triple::hexagon:
1272 case Triple::hsail64:
1274 case Triple::kalimba:
1277 case Triple::mips64el:
1278 case Triple::mipsel:
1279 case Triple::msp430:
1280 case Triple::nvptx64:
1282 case Triple::ppc64le:
1285 case Triple::sparcel:
1286 case Triple::spir64:
1289 case Triple::wasm32:
1290 case Triple::wasm64:
1292 case Triple::x86_64:
1294 // Already little endian.
1297 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1298 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1299 case Triple::mips64: T.setArch(Triple::mips64el); break;
1300 case Triple::mips: T.setArch(Triple::mipsel); break;
1301 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1302 case Triple::sparc: T.setArch(Triple::sparcel); break;
1307 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1309 MArch = getArchName();
1310 MArch = ARM::getCanonicalArchName(MArch);
1312 // Some defaults are forced.
1314 case llvm::Triple::FreeBSD:
1315 case llvm::Triple::NetBSD:
1316 if (!MArch.empty() && MArch == "v6")
1317 return "arm1176jzf-s";
1319 case llvm::Triple::Win32:
1320 // FIXME: this is invalid for WindowsCE
1329 StringRef CPU = ARM::getDefaultCPU(MArch);
1333 // If no specific architecture version is requested, return the minimum CPU
1334 // required by the OS and environment.
1336 case llvm::Triple::NetBSD:
1337 switch (getEnvironment()) {
1338 case llvm::Triple::GNUEABIHF:
1339 case llvm::Triple::GNUEABI:
1340 case llvm::Triple::EABIHF:
1341 case llvm::Triple::EABI:
1342 return "arm926ej-s";
1346 case llvm::Triple::NaCl:
1349 switch (getEnvironment()) {
1350 case llvm::Triple::EABIHF:
1351 case llvm::Triple::GNUEABIHF:
1352 return "arm1176jzf-s";
1358 llvm_unreachable("invalid arch name");