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";
186 llvm_unreachable("Invalid OSType");
189 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
191 case UnknownEnvironment: return "unknown";
192 case GNU: return "gnu";
193 case GNUEABIHF: return "gnueabihf";
194 case GNUEABI: return "gnueabi";
195 case GNUX32: return "gnux32";
196 case CODE16: return "code16";
197 case EABI: return "eabi";
198 case EABIHF: return "eabihf";
199 case Android: return "android";
200 case MSVC: return "msvc";
201 case Itanium: return "itanium";
202 case Cygnus: return "cygnus";
203 case AMDOpenCL: return "amdopencl";
204 case CoreCLR: return "coreclr";
207 llvm_unreachable("Invalid EnvironmentType!");
210 static Triple::ArchType parseBPFArch(StringRef ArchName) {
211 if (ArchName.equals("bpf")) {
212 if (sys::IsLittleEndianHost)
213 return Triple::bpfel;
215 return Triple::bpfeb;
216 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
217 return Triple::bpfeb;
218 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
219 return Triple::bpfel;
221 return Triple::UnknownArch;
225 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
226 Triple::ArchType BPFArch(parseBPFArch(Name));
227 return StringSwitch<Triple::ArchType>(Name)
228 .Case("aarch64", aarch64)
229 .Case("aarch64_be", aarch64_be)
230 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
232 .Case("armeb", armeb)
234 .StartsWith("bpf", BPFArch)
236 .Case("mipsel", mipsel)
237 .Case("mips64", mips64)
238 .Case("mips64el", mips64el)
239 .Case("msp430", msp430)
240 .Case("ppc64", ppc64)
243 .Case("ppc64le", ppc64le)
245 .Case("amdgcn", amdgcn)
246 .Case("hexagon", hexagon)
247 .Case("sparc", sparc)
248 .Case("sparcel", sparcel)
249 .Case("sparcv9", sparcv9)
250 .Case("systemz", systemz)
252 .Case("thumb", thumb)
253 .Case("thumbeb", thumbeb)
255 .Case("x86-64", x86_64)
256 .Case("xcore", xcore)
257 .Case("nvptx", nvptx)
258 .Case("nvptx64", nvptx64)
261 .Case("amdil", amdil)
262 .Case("amdil64", amdil64)
263 .Case("hsail", hsail)
264 .Case("hsail64", hsail64)
266 .Case("spir64", spir64)
267 .Case("kalimba", kalimba)
268 .Case("shave", shave)
269 .Case("wasm32", wasm32)
270 .Case("wasm64", wasm64)
271 .Default(UnknownArch);
274 static Triple::ArchType parseARMArch(StringRef ArchName) {
275 unsigned ISA = ARM::parseArchISA(ArchName);
276 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
278 Triple::ArchType arch = Triple::UnknownArch;
280 case ARM::EK_LITTLE: {
286 arch = Triple::thumb;
288 case ARM::IK_AARCH64:
289 arch = Triple::aarch64;
297 arch = Triple::armeb;
300 arch = Triple::thumbeb;
302 case ARM::IK_AARCH64:
303 arch = Triple::aarch64_be;
310 ArchName = ARM::getCanonicalArchName(ArchName);
311 if (ArchName.empty())
312 return Triple::UnknownArch;
314 // Thumb only exists in v4+
315 if (ISA == ARM::IK_THUMB &&
316 (ArchName.startswith("v2") || ArchName.startswith("v3")))
317 return Triple::UnknownArch;
319 // Thumb only for v6m
320 unsigned Profile = ARM::parseArchProfile(ArchName);
321 unsigned Version = ARM::parseArchVersion(ArchName);
322 if (Profile == ARM::PK_M && Version == 6) {
323 if (ENDIAN == ARM::EK_BIG)
324 return Triple::thumbeb;
326 return Triple::thumb;
332 static Triple::ArchType parseArch(StringRef ArchName) {
333 auto AT = StringSwitch<Triple::ArchType>(ArchName)
334 .Cases("i386", "i486", "i586", "i686", Triple::x86)
335 // FIXME: Do we need to support these?
336 .Cases("i786", "i886", "i986", Triple::x86)
337 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
338 .Case("powerpc", Triple::ppc)
339 .Cases("powerpc64", "ppu", Triple::ppc64)
340 .Case("powerpc64le", Triple::ppc64le)
341 .Case("xscale", Triple::arm)
342 .Case("xscaleeb", Triple::armeb)
343 .Case("aarch64", Triple::aarch64)
344 .Case("aarch64_be", Triple::aarch64_be)
345 .Case("arm64", Triple::aarch64)
346 .Case("arm", Triple::arm)
347 .Case("armeb", Triple::armeb)
348 .Case("thumb", Triple::thumb)
349 .Case("thumbeb", Triple::thumbeb)
350 .Case("avr", Triple::avr)
351 .Case("msp430", Triple::msp430)
352 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
353 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
354 .Cases("mips64", "mips64eb", Triple::mips64)
355 .Case("mips64el", Triple::mips64el)
356 .Case("r600", Triple::r600)
357 .Case("amdgcn", Triple::amdgcn)
358 .Case("hexagon", Triple::hexagon)
359 .Case("s390x", Triple::systemz)
360 .Case("sparc", Triple::sparc)
361 .Case("sparcel", Triple::sparcel)
362 .Cases("sparcv9", "sparc64", Triple::sparcv9)
363 .Case("tce", Triple::tce)
364 .Case("xcore", Triple::xcore)
365 .Case("nvptx", Triple::nvptx)
366 .Case("nvptx64", Triple::nvptx64)
367 .Case("le32", Triple::le32)
368 .Case("le64", Triple::le64)
369 .Case("amdil", Triple::amdil)
370 .Case("amdil64", Triple::amdil64)
371 .Case("hsail", Triple::hsail)
372 .Case("hsail64", Triple::hsail64)
373 .Case("spir", Triple::spir)
374 .Case("spir64", Triple::spir64)
375 .StartsWith("kalimba", Triple::kalimba)
376 .Case("shave", Triple::shave)
377 .Case("wasm32", Triple::wasm32)
378 .Case("wasm64", Triple::wasm64)
379 .Default(Triple::UnknownArch);
381 // Some architectures require special parsing logic just to compute the
383 if (AT == Triple::UnknownArch) {
384 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
385 ArchName.startswith("aarch64"))
386 return parseARMArch(ArchName);
387 if (ArchName.startswith("bpf"))
388 return parseBPFArch(ArchName);
394 static Triple::VendorType parseVendor(StringRef VendorName) {
395 return StringSwitch<Triple::VendorType>(VendorName)
396 .Case("apple", Triple::Apple)
397 .Case("pc", Triple::PC)
398 .Case("scei", Triple::SCEI)
399 .Case("bgp", Triple::BGP)
400 .Case("bgq", Triple::BGQ)
401 .Case("fsl", Triple::Freescale)
402 .Case("ibm", Triple::IBM)
403 .Case("img", Triple::ImaginationTechnologies)
404 .Case("mti", Triple::MipsTechnologies)
405 .Case("nvidia", Triple::NVIDIA)
406 .Case("csr", Triple::CSR)
407 .Case("myriad", Triple::Myriad)
408 .Default(Triple::UnknownVendor);
411 static Triple::OSType parseOS(StringRef OSName) {
412 return StringSwitch<Triple::OSType>(OSName)
413 .StartsWith("cloudabi", Triple::CloudABI)
414 .StartsWith("darwin", Triple::Darwin)
415 .StartsWith("dragonfly", Triple::DragonFly)
416 .StartsWith("freebsd", Triple::FreeBSD)
417 .StartsWith("ios", Triple::IOS)
418 .StartsWith("kfreebsd", Triple::KFreeBSD)
419 .StartsWith("linux", Triple::Linux)
420 .StartsWith("lv2", Triple::Lv2)
421 .StartsWith("macosx", Triple::MacOSX)
422 .StartsWith("netbsd", Triple::NetBSD)
423 .StartsWith("openbsd", Triple::OpenBSD)
424 .StartsWith("solaris", Triple::Solaris)
425 .StartsWith("win32", Triple::Win32)
426 .StartsWith("windows", Triple::Win32)
427 .StartsWith("haiku", Triple::Haiku)
428 .StartsWith("minix", Triple::Minix)
429 .StartsWith("rtems", Triple::RTEMS)
430 .StartsWith("nacl", Triple::NaCl)
431 .StartsWith("cnk", Triple::CNK)
432 .StartsWith("bitrig", Triple::Bitrig)
433 .StartsWith("aix", Triple::AIX)
434 .StartsWith("cuda", Triple::CUDA)
435 .StartsWith("nvcl", Triple::NVCL)
436 .StartsWith("amdhsa", Triple::AMDHSA)
437 .StartsWith("ps4", Triple::PS4)
438 .Default(Triple::UnknownOS);
441 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
442 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
443 .StartsWith("eabihf", Triple::EABIHF)
444 .StartsWith("eabi", Triple::EABI)
445 .StartsWith("gnueabihf", Triple::GNUEABIHF)
446 .StartsWith("gnueabi", Triple::GNUEABI)
447 .StartsWith("gnux32", Triple::GNUX32)
448 .StartsWith("code16", Triple::CODE16)
449 .StartsWith("gnu", Triple::GNU)
450 .StartsWith("android", Triple::Android)
451 .StartsWith("msvc", Triple::MSVC)
452 .StartsWith("itanium", Triple::Itanium)
453 .StartsWith("cygnus", Triple::Cygnus)
454 .StartsWith("amdopencl", Triple::AMDOpenCL)
455 .StartsWith("coreclr", Triple::CoreCLR)
456 .Default(Triple::UnknownEnvironment);
459 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
460 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
461 .EndsWith("coff", Triple::COFF)
462 .EndsWith("elf", Triple::ELF)
463 .EndsWith("macho", Triple::MachO)
464 .Default(Triple::UnknownObjectFormat);
467 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
468 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
470 // For now, this is the small part. Early return.
471 if (ARMSubArch.empty())
472 return StringSwitch<Triple::SubArchType>(SubArchName)
473 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
474 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
475 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
476 .Default(Triple::NoSubArch);
479 switch(ARM::parseArch(ARMSubArch)) {
481 return Triple::NoSubArch;
483 return Triple::ARMSubArch_v4t;
487 return Triple::ARMSubArch_v5;
488 case ARM::AK_ARMV5TE:
490 case ARM::AK_IWMMXT2:
492 case ARM::AK_ARMV5TEJ:
493 return Triple::ARMSubArch_v5te;
497 return Triple::ARMSubArch_v6;
499 case ARM::AK_ARMV6ZK:
500 case ARM::AK_ARMV6HL:
501 return Triple::ARMSubArch_v6k;
502 case ARM::AK_ARMV6T2:
503 return Triple::ARMSubArch_v6t2;
505 case ARM::AK_ARMV6SM:
506 return Triple::ARMSubArch_v6m;
511 case ARM::AK_ARMV7HL:
512 return Triple::ARMSubArch_v7;
514 return Triple::ARMSubArch_v7m;
516 return Triple::ARMSubArch_v7s;
517 case ARM::AK_ARMV7EM:
518 return Triple::ARMSubArch_v7em;
520 return Triple::ARMSubArch_v8;
521 case ARM::AK_ARMV8_1A:
522 return Triple::ARMSubArch_v8_1a;
524 return Triple::NoSubArch;
528 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
530 case Triple::UnknownObjectFormat: return "";
531 case Triple::COFF: return "coff";
532 case Triple::ELF: return "elf";
533 case Triple::MachO: return "macho";
535 llvm_unreachable("unknown object format type");
538 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
539 switch (T.getArch()) {
542 case Triple::hexagon:
546 case Triple::mips64el:
550 case Triple::sparcv9:
551 case Triple::systemz:
553 case Triple::ppc64le:
559 return Triple::MachO;
564 // Unknown for now, until an object format is specified.
565 return Triple::UnknownObjectFormat;
569 return Triple::MachO;
570 else if (T.isOSWindows())
575 /// \brief Construct a triple from the string representation provided.
577 /// This stores the string representation and parses the various pieces into
579 Triple::Triple(const Twine &Str)
580 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
581 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
582 ObjectFormat(UnknownObjectFormat) {
583 // Do minimal parsing by hand here.
584 SmallVector<StringRef, 4> Components;
585 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
586 if (Components.size() > 0) {
587 Arch = parseArch(Components[0]);
588 SubArch = parseSubArch(Components[0]);
589 if (Components.size() > 1) {
590 Vendor = parseVendor(Components[1]);
591 if (Components.size() > 2) {
592 OS = parseOS(Components[2]);
593 if (Components.size() > 3) {
594 Environment = parseEnvironment(Components[3]);
595 ObjectFormat = parseFormat(Components[3]);
600 if (ObjectFormat == UnknownObjectFormat)
601 ObjectFormat = getDefaultFormat(*this);
604 /// \brief Construct a triple from string representations of the architecture,
607 /// This joins each argument into a canonical string representation and parses
608 /// them into enum members. It leaves the environment unknown and omits it from
609 /// the string representation.
610 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
611 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
612 Arch(parseArch(ArchStr.str())),
613 SubArch(parseSubArch(ArchStr.str())),
614 Vendor(parseVendor(VendorStr.str())),
615 OS(parseOS(OSStr.str())),
616 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
617 ObjectFormat = getDefaultFormat(*this);
620 /// \brief Construct a triple from string representations of the architecture,
621 /// vendor, OS, and environment.
623 /// This joins each argument into a canonical string representation and parses
624 /// them into enum members.
625 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
626 const Twine &EnvironmentStr)
627 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
628 EnvironmentStr).str()),
629 Arch(parseArch(ArchStr.str())),
630 SubArch(parseSubArch(ArchStr.str())),
631 Vendor(parseVendor(VendorStr.str())),
632 OS(parseOS(OSStr.str())),
633 Environment(parseEnvironment(EnvironmentStr.str())),
634 ObjectFormat(parseFormat(EnvironmentStr.str())) {
635 if (ObjectFormat == Triple::UnknownObjectFormat)
636 ObjectFormat = getDefaultFormat(*this);
639 std::string Triple::normalize(StringRef Str) {
640 bool IsMinGW32 = false;
641 bool IsCygwin = false;
643 // Parse into components.
644 SmallVector<StringRef, 4> Components;
645 Str.split(Components, '-');
647 // If the first component corresponds to a known architecture, preferentially
648 // use it for the architecture. If the second component corresponds to a
649 // known vendor, preferentially use it for the vendor, etc. This avoids silly
650 // component movement when a component parses as (eg) both a valid arch and a
652 ArchType Arch = UnknownArch;
653 if (Components.size() > 0)
654 Arch = parseArch(Components[0]);
655 VendorType Vendor = UnknownVendor;
656 if (Components.size() > 1)
657 Vendor = parseVendor(Components[1]);
658 OSType OS = UnknownOS;
659 if (Components.size() > 2) {
660 OS = parseOS(Components[2]);
661 IsCygwin = Components[2].startswith("cygwin");
662 IsMinGW32 = Components[2].startswith("mingw");
664 EnvironmentType Environment = UnknownEnvironment;
665 if (Components.size() > 3)
666 Environment = parseEnvironment(Components[3]);
667 ObjectFormatType ObjectFormat = UnknownObjectFormat;
668 if (Components.size() > 4)
669 ObjectFormat = parseFormat(Components[4]);
671 // Note which components are already in their final position. These will not
674 Found[0] = Arch != UnknownArch;
675 Found[1] = Vendor != UnknownVendor;
676 Found[2] = OS != UnknownOS;
677 Found[3] = Environment != UnknownEnvironment;
679 // If they are not there already, permute the components into their canonical
680 // positions by seeing if they parse as a valid architecture, and if so moving
681 // the component to the architecture position etc.
682 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
684 continue; // Already in the canonical position.
686 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
687 // Do not reparse any components that already matched.
688 if (Idx < array_lengthof(Found) && Found[Idx])
691 // Does this component parse as valid for the target position?
693 StringRef Comp = Components[Idx];
695 default: llvm_unreachable("unexpected component type!");
697 Arch = parseArch(Comp);
698 Valid = Arch != UnknownArch;
701 Vendor = parseVendor(Comp);
702 Valid = Vendor != UnknownVendor;
706 IsCygwin = Comp.startswith("cygwin");
707 IsMinGW32 = Comp.startswith("mingw");
708 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
711 Environment = parseEnvironment(Comp);
712 Valid = Environment != UnknownEnvironment;
714 ObjectFormat = parseFormat(Comp);
715 Valid = ObjectFormat != UnknownObjectFormat;
720 continue; // Nope, try the next component.
722 // Move the component to the target position, pushing any non-fixed
723 // components that are in the way to the right. This tends to give
724 // good results in the common cases of a forgotten vendor component
725 // or a wrongly positioned environment.
727 // Insert left, pushing the existing components to the right. For
728 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
729 StringRef CurrentComponent(""); // The empty component.
730 // Replace the component we are moving with an empty component.
731 std::swap(CurrentComponent, Components[Idx]);
732 // Insert the component being moved at Pos, displacing any existing
733 // components to the right.
734 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
735 // Skip over any fixed components.
736 while (i < array_lengthof(Found) && Found[i])
738 // Place the component at the new position, getting the component
739 // that was at this position - it will be moved right.
740 std::swap(CurrentComponent, Components[i]);
742 } else if (Pos > Idx) {
743 // Push right by inserting empty components until the component at Idx
744 // reaches the target position Pos. For example, pc-a -> -pc-a when
745 // moving pc to the second position.
747 // Insert one empty component at Idx.
748 StringRef CurrentComponent(""); // The empty component.
749 for (unsigned i = Idx; i < Components.size();) {
750 // Place the component at the new position, getting the component
751 // that was at this position - it will be moved right.
752 std::swap(CurrentComponent, Components[i]);
753 // If it was placed on top of an empty component then we are done.
754 if (CurrentComponent.empty())
756 // Advance to the next component, skipping any fixed components.
757 while (++i < array_lengthof(Found) && Found[i])
760 // The last component was pushed off the end - append it.
761 if (!CurrentComponent.empty())
762 Components.push_back(CurrentComponent);
764 // Advance Idx to the component's new position.
765 while (++Idx < array_lengthof(Found) && Found[Idx])
767 } while (Idx < Pos); // Add more until the final position is reached.
769 assert(Pos < Components.size() && Components[Pos] == Comp &&
770 "Component moved wrong!");
776 // Special case logic goes here. At this point Arch, Vendor and OS have the
777 // correct values for the computed components.
778 std::string NormalizedEnvironment;
779 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
780 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
781 if (AndroidVersion.empty()) {
782 Components[3] = "android";
784 NormalizedEnvironment = Twine("android", AndroidVersion).str();
785 Components[3] = NormalizedEnvironment;
789 if (OS == Triple::Win32) {
790 Components.resize(4);
791 Components[2] = "windows";
792 if (Environment == UnknownEnvironment) {
793 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
794 Components[3] = "msvc";
796 Components[3] = getObjectFormatTypeName(ObjectFormat);
798 } else if (IsMinGW32) {
799 Components.resize(4);
800 Components[2] = "windows";
801 Components[3] = "gnu";
802 } else if (IsCygwin) {
803 Components.resize(4);
804 Components[2] = "windows";
805 Components[3] = "cygnus";
807 if (IsMinGW32 || IsCygwin ||
808 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
809 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
810 Components.resize(5);
811 Components[4] = getObjectFormatTypeName(ObjectFormat);
815 // Stick the corrected components back together to form the normalized string.
816 std::string Normalized;
817 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
818 if (i) Normalized += '-';
819 Normalized += Components[i];
824 StringRef Triple::getArchName() const {
825 return StringRef(Data).split('-').first; // Isolate first component
828 StringRef Triple::getVendorName() const {
829 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
830 return Tmp.split('-').first; // Isolate second component
833 StringRef Triple::getOSName() const {
834 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
835 Tmp = Tmp.split('-').second; // Strip second component
836 return Tmp.split('-').first; // Isolate third component
839 StringRef Triple::getEnvironmentName() const {
840 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
841 Tmp = Tmp.split('-').second; // Strip second component
842 return Tmp.split('-').second; // Strip third component
845 StringRef Triple::getOSAndEnvironmentName() const {
846 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
847 return Tmp.split('-').second; // Strip second component
850 static unsigned EatNumber(StringRef &Str) {
851 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
855 // Consume the leading digit.
856 Result = Result*10 + (Str[0] - '0');
860 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
865 static void parseVersionFromName(StringRef Name, unsigned &Major,
866 unsigned &Minor, unsigned &Micro) {
867 // Any unset version defaults to 0.
868 Major = Minor = Micro = 0;
870 // Parse up to three components.
871 unsigned *Components[3] = {&Major, &Minor, &Micro};
872 for (unsigned i = 0; i != 3; ++i) {
873 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
876 // Consume the leading number.
877 *Components[i] = EatNumber(Name);
879 // Consume the separator, if present.
880 if (Name.startswith("."))
881 Name = Name.substr(1);
885 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
886 unsigned &Micro) const {
887 StringRef EnvironmentName = getEnvironmentName();
888 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
889 if (EnvironmentName.startswith(EnvironmentTypeName))
890 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
892 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
895 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
896 unsigned &Micro) const {
897 StringRef OSName = getOSName();
898 // Assume that the OS portion of the triple starts with the canonical name.
899 StringRef OSTypeName = getOSTypeName(getOS());
900 if (OSName.startswith(OSTypeName))
901 OSName = OSName.substr(OSTypeName.size());
903 parseVersionFromName(OSName, Major, Minor, Micro);
906 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
907 unsigned &Micro) const {
908 getOSVersion(Major, Minor, Micro);
911 default: llvm_unreachable("unexpected OS for Darwin triple");
913 // Default to darwin8, i.e., MacOSX 10.4.
916 // Darwin version numbers are skewed from OS X versions.
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 OS X version number even when targeting
945 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
946 unsigned &Micro) const {
948 default: llvm_unreachable("unexpected OS for Darwin triple");
951 // Ignore the version from the triple. This is only handled because the
952 // the clang driver combines OS X and IOS support into a common Darwin
953 // toolchain that wants to know the iOS version number even when targeting
960 getOSVersion(Major, Minor, Micro);
961 // Default to 5.0 (or 7.0 for arm64).
963 Major = (getArch() == aarch64) ? 7 : 5;
968 void Triple::setTriple(const Twine &Str) {
972 void Triple::setArch(ArchType Kind) {
973 setArchName(getArchTypeName(Kind));
976 void Triple::setVendor(VendorType Kind) {
977 setVendorName(getVendorTypeName(Kind));
980 void Triple::setOS(OSType Kind) {
981 setOSName(getOSTypeName(Kind));
984 void Triple::setEnvironment(EnvironmentType Kind) {
985 if (ObjectFormat == getDefaultFormat(*this))
986 return setEnvironmentName(getEnvironmentTypeName(Kind));
988 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
989 getObjectFormatTypeName(ObjectFormat)).str());
992 void Triple::setObjectFormat(ObjectFormatType Kind) {
993 if (Environment == UnknownEnvironment)
994 return setEnvironmentName(getObjectFormatTypeName(Kind));
996 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
997 getObjectFormatTypeName(Kind)).str());
1000 void Triple::setArchName(StringRef Str) {
1001 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1002 SmallString<64> Triple;
1005 Triple += getVendorName();
1007 Triple += getOSAndEnvironmentName();
1011 void Triple::setVendorName(StringRef Str) {
1012 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1015 void Triple::setOSName(StringRef Str) {
1016 if (hasEnvironment())
1017 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1018 "-" + getEnvironmentName());
1020 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1023 void Triple::setEnvironmentName(StringRef Str) {
1024 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1028 void Triple::setOSAndEnvironmentName(StringRef Str) {
1029 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1032 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1034 case llvm::Triple::UnknownArch:
1037 case llvm::Triple::avr:
1038 case llvm::Triple::msp430:
1041 case llvm::Triple::arm:
1042 case llvm::Triple::armeb:
1043 case llvm::Triple::hexagon:
1044 case llvm::Triple::le32:
1045 case llvm::Triple::mips:
1046 case llvm::Triple::mipsel:
1047 case llvm::Triple::nvptx:
1048 case llvm::Triple::ppc:
1049 case llvm::Triple::r600:
1050 case llvm::Triple::sparc:
1051 case llvm::Triple::sparcel:
1052 case llvm::Triple::tce:
1053 case llvm::Triple::thumb:
1054 case llvm::Triple::thumbeb:
1055 case llvm::Triple::x86:
1056 case llvm::Triple::xcore:
1057 case llvm::Triple::amdil:
1058 case llvm::Triple::hsail:
1059 case llvm::Triple::spir:
1060 case llvm::Triple::kalimba:
1061 case llvm::Triple::shave:
1062 case llvm::Triple::wasm32:
1065 case llvm::Triple::aarch64:
1066 case llvm::Triple::aarch64_be:
1067 case llvm::Triple::amdgcn:
1068 case llvm::Triple::bpfel:
1069 case llvm::Triple::bpfeb:
1070 case llvm::Triple::le64:
1071 case llvm::Triple::mips64:
1072 case llvm::Triple::mips64el:
1073 case llvm::Triple::nvptx64:
1074 case llvm::Triple::ppc64:
1075 case llvm::Triple::ppc64le:
1076 case llvm::Triple::sparcv9:
1077 case llvm::Triple::systemz:
1078 case llvm::Triple::x86_64:
1079 case llvm::Triple::amdil64:
1080 case llvm::Triple::hsail64:
1081 case llvm::Triple::spir64:
1082 case llvm::Triple::wasm64:
1085 llvm_unreachable("Invalid architecture value");
1088 bool Triple::isArch64Bit() const {
1089 return getArchPointerBitWidth(getArch()) == 64;
1092 bool Triple::isArch32Bit() const {
1093 return getArchPointerBitWidth(getArch()) == 32;
1096 bool Triple::isArch16Bit() const {
1097 return getArchPointerBitWidth(getArch()) == 16;
1100 Triple Triple::get32BitArchVariant() const {
1102 switch (getArch()) {
1103 case Triple::UnknownArch:
1104 case Triple::aarch64:
1105 case Triple::aarch64_be:
1106 case Triple::amdgcn:
1110 case Triple::msp430:
1111 case Triple::systemz:
1112 case Triple::ppc64le:
1113 T.setArch(UnknownArch);
1121 case Triple::hexagon:
1122 case Triple::kalimba:
1125 case Triple::mipsel:
1130 case Triple::sparcel:
1133 case Triple::thumbeb:
1137 case Triple::wasm32:
1141 case Triple::le64: T.setArch(Triple::le32); break;
1142 case Triple::mips64: T.setArch(Triple::mips); break;
1143 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1144 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1145 case Triple::ppc64: T.setArch(Triple::ppc); break;
1146 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1147 case Triple::x86_64: T.setArch(Triple::x86); break;
1148 case Triple::amdil64: T.setArch(Triple::amdil); break;
1149 case Triple::hsail64: T.setArch(Triple::hsail); break;
1150 case Triple::spir64: T.setArch(Triple::spir); break;
1151 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1156 Triple Triple::get64BitArchVariant() const {
1158 switch (getArch()) {
1159 case Triple::UnknownArch:
1163 case Triple::hexagon:
1164 case Triple::kalimba:
1165 case Triple::msp430:
1169 case Triple::thumbeb:
1171 case Triple::sparcel:
1173 T.setArch(UnknownArch);
1176 case Triple::aarch64:
1177 case Triple::aarch64_be:
1181 case Triple::amdil64:
1182 case Triple::amdgcn:
1183 case Triple::hsail64:
1184 case Triple::spir64:
1185 case Triple::mips64:
1186 case Triple::mips64el:
1187 case Triple::nvptx64:
1189 case Triple::ppc64le:
1190 case Triple::sparcv9:
1191 case Triple::systemz:
1192 case Triple::x86_64:
1193 case Triple::wasm64:
1197 case Triple::le32: T.setArch(Triple::le64); break;
1198 case Triple::mips: T.setArch(Triple::mips64); break;
1199 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1200 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1201 case Triple::ppc: T.setArch(Triple::ppc64); break;
1202 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1203 case Triple::x86: T.setArch(Triple::x86_64); break;
1204 case Triple::amdil: T.setArch(Triple::amdil64); break;
1205 case Triple::hsail: T.setArch(Triple::hsail64); break;
1206 case Triple::spir: T.setArch(Triple::spir64); break;
1207 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1212 Triple Triple::getBigEndianArchVariant() const {
1214 switch (getArch()) {
1215 case Triple::UnknownArch:
1216 case Triple::amdgcn:
1217 case Triple::amdil64:
1220 case Triple::hexagon:
1221 case Triple::hsail64:
1223 case Triple::kalimba:
1226 case Triple::msp430:
1227 case Triple::nvptx64:
1231 case Triple::spir64:
1233 case Triple::wasm32:
1234 case Triple::wasm64:
1236 case Triple::x86_64:
1239 // ARM is intentionally unsupported here, changing the architecture would
1240 // drop any arch suffixes.
1243 T.setArch(UnknownArch);
1246 case Triple::aarch64_be:
1249 case Triple::mips64:
1254 case Triple::sparcv9:
1255 case Triple::systemz:
1257 case Triple::thumbeb:
1258 // Already big endian.
1261 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1262 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1263 case Triple::mips64el:T.setArch(Triple::mips64); break;
1264 case Triple::mipsel: T.setArch(Triple::mips); break;
1265 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1266 case Triple::sparcel: T.setArch(Triple::sparc); break;
1271 Triple Triple::getLittleEndianArchVariant() const {
1273 switch (getArch()) {
1274 case Triple::UnknownArch:
1276 case Triple::sparcv9:
1277 case Triple::systemz:
1280 // ARM is intentionally unsupported here, changing the architecture would
1281 // drop any arch suffixes.
1283 case Triple::thumbeb:
1284 T.setArch(UnknownArch);
1287 case Triple::aarch64:
1288 case Triple::amdgcn:
1289 case Triple::amdil64:
1294 case Triple::hexagon:
1295 case Triple::hsail64:
1297 case Triple::kalimba:
1300 case Triple::mips64el:
1301 case Triple::mipsel:
1302 case Triple::msp430:
1303 case Triple::nvptx64:
1305 case Triple::ppc64le:
1308 case Triple::sparcel:
1309 case Triple::spir64:
1312 case Triple::wasm32:
1313 case Triple::wasm64:
1315 case Triple::x86_64:
1317 // Already little endian.
1320 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1321 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1322 case Triple::mips64: T.setArch(Triple::mips64el); break;
1323 case Triple::mips: T.setArch(Triple::mipsel); break;
1324 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1325 case Triple::sparc: T.setArch(Triple::sparcel); break;
1330 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1332 MArch = getArchName();
1333 MArch = ARM::getCanonicalArchName(MArch);
1335 // Some defaults are forced.
1337 case llvm::Triple::FreeBSD:
1338 case llvm::Triple::NetBSD:
1339 if (!MArch.empty() && MArch == "v6")
1340 return "arm1176jzf-s";
1342 case llvm::Triple::Win32:
1343 // FIXME: this is invalid for WindowsCE
1352 StringRef CPU = ARM::getDefaultCPU(MArch);
1356 // If no specific architecture version is requested, return the minimum CPU
1357 // required by the OS and environment.
1359 case llvm::Triple::NetBSD:
1360 switch (getEnvironment()) {
1361 case llvm::Triple::GNUEABIHF:
1362 case llvm::Triple::GNUEABI:
1363 case llvm::Triple::EABIHF:
1364 case llvm::Triple::EABI:
1365 return "arm926ej-s";
1369 case llvm::Triple::NaCl:
1372 switch (getEnvironment()) {
1373 case llvm::Triple::EABIHF:
1374 case llvm::Triple::GNUEABIHF:
1375 return "arm1176jzf-s";
1381 llvm_unreachable("invalid arch name");