1 //===--- Triple.cpp - Target triple helper class --------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/Triple.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringSwitch.h"
14 #include "llvm/Support/ErrorHandling.h"
15 #include "llvm/Support/TargetParser.h"
16 #include "llvm/Support/Host.h"
20 const char *Triple::getArchTypeName(ArchType Kind) {
22 case UnknownArch: return "unknown";
24 case aarch64: return "aarch64";
25 case aarch64_be: return "aarch64_be";
26 case arm: return "arm";
27 case armeb: return "armeb";
28 case avr: return "avr";
29 case bpfel: return "bpfel";
30 case bpfeb: return "bpfeb";
31 case hexagon: return "hexagon";
32 case mips: return "mips";
33 case mipsel: return "mipsel";
34 case mips64: return "mips64";
35 case mips64el: return "mips64el";
36 case msp430: return "msp430";
37 case ppc64: return "powerpc64";
38 case ppc64le: return "powerpc64le";
39 case ppc: return "powerpc";
40 case r600: return "r600";
41 case amdgcn: return "amdgcn";
42 case sparc: return "sparc";
43 case sparcv9: return "sparcv9";
44 case sparcel: return "sparcel";
45 case systemz: return "s390x";
46 case tce: return "tce";
47 case thumb: return "thumb";
48 case thumbeb: return "thumbeb";
49 case x86: return "i386";
50 case x86_64: return "x86_64";
51 case xcore: return "xcore";
52 case nvptx: return "nvptx";
53 case nvptx64: return "nvptx64";
54 case le32: return "le32";
55 case le64: return "le64";
56 case amdil: return "amdil";
57 case amdil64: return "amdil64";
58 case hsail: return "hsail";
59 case hsail64: return "hsail64";
60 case spir: return "spir";
61 case spir64: return "spir64";
62 case kalimba: return "kalimba";
63 case shave: return "shave";
64 case wasm32: return "wasm32";
65 case wasm64: return "wasm64";
68 llvm_unreachable("Invalid ArchType!");
71 const char *Triple::getArchTypePrefix(ArchType Kind) {
77 case aarch64_be: return "aarch64";
82 case thumbeb: return "arm";
84 case avr: return "avr";
88 case ppc: return "ppc";
93 case mips64el: return "mips";
95 case hexagon: return "hexagon";
98 case r600: return "amdgpu";
101 case bpfeb: return "bpf";
105 case sparc: return "sparc";
107 case systemz: return "s390";
110 case x86_64: return "x86";
112 case xcore: return "xcore";
114 case nvptx: return "nvptx";
115 case nvptx64: return "nvptx";
117 case le32: return "le32";
118 case le64: return "le64";
121 case amdil64: return "amdil";
124 case hsail64: return "hsail";
127 case spir64: return "spir";
128 case kalimba: return "kalimba";
129 case shave: return "shave";
131 case wasm64: return "wasm";
135 const char *Triple::getVendorTypeName(VendorType Kind) {
137 case UnknownVendor: return "unknown";
139 case Apple: return "apple";
140 case PC: return "pc";
141 case SCEI: return "scei";
142 case BGP: return "bgp";
143 case BGQ: return "bgq";
144 case Freescale: return "fsl";
145 case IBM: return "ibm";
146 case ImaginationTechnologies: return "img";
147 case MipsTechnologies: return "mti";
148 case NVIDIA: return "nvidia";
149 case CSR: return "csr";
150 case Myriad: return "myriad";
153 llvm_unreachable("Invalid VendorType!");
156 const char *Triple::getOSTypeName(OSType Kind) {
158 case UnknownOS: return "unknown";
160 case CloudABI: return "cloudabi";
161 case Darwin: return "darwin";
162 case DragonFly: return "dragonfly";
163 case FreeBSD: return "freebsd";
164 case IOS: return "ios";
165 case KFreeBSD: return "kfreebsd";
166 case Linux: return "linux";
167 case Lv2: return "lv2";
168 case MacOSX: return "macosx";
169 case NetBSD: return "netbsd";
170 case OpenBSD: return "openbsd";
171 case Solaris: return "solaris";
172 case Win32: return "windows";
173 case Haiku: return "haiku";
174 case Minix: return "minix";
175 case RTEMS: return "rtems";
176 case NaCl: return "nacl";
177 case CNK: return "cnk";
178 case Bitrig: return "bitrig";
179 case AIX: return "aix";
180 case CUDA: return "cuda";
181 case NVCL: return "nvcl";
182 case AMDHSA: return "amdhsa";
183 case PS4: return "ps4";
184 case ELFIAMCU: return "elfiamcu";
187 llvm_unreachable("Invalid OSType");
190 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
192 case UnknownEnvironment: return "unknown";
193 case GNU: return "gnu";
194 case GNUEABIHF: return "gnueabihf";
195 case GNUEABI: return "gnueabi";
196 case GNUX32: return "gnux32";
197 case CODE16: return "code16";
198 case EABI: return "eabi";
199 case EABIHF: return "eabihf";
200 case Android: return "android";
201 case MSVC: return "msvc";
202 case Itanium: return "itanium";
203 case Cygnus: return "cygnus";
204 case AMDOpenCL: return "amdopencl";
205 case CoreCLR: return "coreclr";
208 llvm_unreachable("Invalid EnvironmentType!");
211 static Triple::ArchType parseBPFArch(StringRef ArchName) {
212 if (ArchName.equals("bpf")) {
213 if (sys::IsLittleEndianHost)
214 return Triple::bpfel;
216 return Triple::bpfeb;
217 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
218 return Triple::bpfeb;
219 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
220 return Triple::bpfel;
222 return Triple::UnknownArch;
226 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
227 Triple::ArchType BPFArch(parseBPFArch(Name));
228 return StringSwitch<Triple::ArchType>(Name)
229 .Case("aarch64", aarch64)
230 .Case("aarch64_be", aarch64_be)
231 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
233 .Case("armeb", armeb)
235 .StartsWith("bpf", BPFArch)
237 .Case("mipsel", mipsel)
238 .Case("mips64", mips64)
239 .Case("mips64el", mips64el)
240 .Case("msp430", msp430)
241 .Case("ppc64", ppc64)
244 .Case("ppc64le", ppc64le)
246 .Case("amdgcn", amdgcn)
247 .Case("hexagon", hexagon)
248 .Case("sparc", sparc)
249 .Case("sparcel", sparcel)
250 .Case("sparcv9", sparcv9)
251 .Case("systemz", systemz)
253 .Case("thumb", thumb)
254 .Case("thumbeb", thumbeb)
256 .Case("x86-64", x86_64)
257 .Case("xcore", xcore)
258 .Case("nvptx", nvptx)
259 .Case("nvptx64", nvptx64)
262 .Case("amdil", amdil)
263 .Case("amdil64", amdil64)
264 .Case("hsail", hsail)
265 .Case("hsail64", hsail64)
267 .Case("spir64", spir64)
268 .Case("kalimba", kalimba)
269 .Case("shave", shave)
270 .Case("wasm32", wasm32)
271 .Case("wasm64", wasm64)
272 .Default(UnknownArch);
275 static Triple::ArchType parseARMArch(StringRef ArchName) {
276 unsigned ISA = ARM::parseArchISA(ArchName);
277 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
279 Triple::ArchType arch = Triple::UnknownArch;
281 case ARM::EK_LITTLE: {
287 arch = Triple::thumb;
289 case ARM::IK_AARCH64:
290 arch = Triple::aarch64;
298 arch = Triple::armeb;
301 arch = Triple::thumbeb;
303 case ARM::IK_AARCH64:
304 arch = Triple::aarch64_be;
311 ArchName = ARM::getCanonicalArchName(ArchName);
312 if (ArchName.empty())
313 return Triple::UnknownArch;
315 // Thumb only exists in v4+
316 if (ISA == ARM::IK_THUMB &&
317 (ArchName.startswith("v2") || ArchName.startswith("v3")))
318 return Triple::UnknownArch;
320 // Thumb only for v6m
321 unsigned Profile = ARM::parseArchProfile(ArchName);
322 unsigned Version = ARM::parseArchVersion(ArchName);
323 if (Profile == ARM::PK_M && Version == 6) {
324 if (ENDIAN == ARM::EK_BIG)
325 return Triple::thumbeb;
327 return Triple::thumb;
333 static Triple::ArchType parseArch(StringRef ArchName) {
334 auto AT = StringSwitch<Triple::ArchType>(ArchName)
335 .Cases("i386", "i486", "i586", "i686", Triple::x86)
336 // FIXME: Do we need to support these?
337 .Cases("i786", "i886", "i986", Triple::x86)
338 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
339 .Case("powerpc", Triple::ppc)
340 .Cases("powerpc64", "ppu", Triple::ppc64)
341 .Case("powerpc64le", Triple::ppc64le)
342 .Case("xscale", Triple::arm)
343 .Case("xscaleeb", Triple::armeb)
344 .Case("aarch64", Triple::aarch64)
345 .Case("aarch64_be", Triple::aarch64_be)
346 .Case("arm64", Triple::aarch64)
347 .Case("arm", Triple::arm)
348 .Case("armeb", Triple::armeb)
349 .Case("thumb", Triple::thumb)
350 .Case("thumbeb", Triple::thumbeb)
351 .Case("avr", Triple::avr)
352 .Case("msp430", Triple::msp430)
353 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
354 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
355 .Cases("mips64", "mips64eb", Triple::mips64)
356 .Case("mips64el", Triple::mips64el)
357 .Case("r600", Triple::r600)
358 .Case("amdgcn", Triple::amdgcn)
359 .Case("hexagon", Triple::hexagon)
360 .Case("s390x", Triple::systemz)
361 .Case("sparc", Triple::sparc)
362 .Case("sparcel", Triple::sparcel)
363 .Cases("sparcv9", "sparc64", Triple::sparcv9)
364 .Case("tce", Triple::tce)
365 .Case("xcore", Triple::xcore)
366 .Case("nvptx", Triple::nvptx)
367 .Case("nvptx64", Triple::nvptx64)
368 .Case("le32", Triple::le32)
369 .Case("le64", Triple::le64)
370 .Case("amdil", Triple::amdil)
371 .Case("amdil64", Triple::amdil64)
372 .Case("hsail", Triple::hsail)
373 .Case("hsail64", Triple::hsail64)
374 .Case("spir", Triple::spir)
375 .Case("spir64", Triple::spir64)
376 .StartsWith("kalimba", Triple::kalimba)
377 .Case("shave", Triple::shave)
378 .Case("wasm32", Triple::wasm32)
379 .Case("wasm64", Triple::wasm64)
380 .Default(Triple::UnknownArch);
382 // Some architectures require special parsing logic just to compute the
384 if (AT == Triple::UnknownArch) {
385 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
386 ArchName.startswith("aarch64"))
387 return parseARMArch(ArchName);
388 if (ArchName.startswith("bpf"))
389 return parseBPFArch(ArchName);
395 static Triple::VendorType parseVendor(StringRef VendorName) {
396 return StringSwitch<Triple::VendorType>(VendorName)
397 .Case("apple", Triple::Apple)
398 .Case("pc", Triple::PC)
399 .Case("scei", Triple::SCEI)
400 .Case("bgp", Triple::BGP)
401 .Case("bgq", Triple::BGQ)
402 .Case("fsl", Triple::Freescale)
403 .Case("ibm", Triple::IBM)
404 .Case("img", Triple::ImaginationTechnologies)
405 .Case("mti", Triple::MipsTechnologies)
406 .Case("nvidia", Triple::NVIDIA)
407 .Case("csr", Triple::CSR)
408 .Case("myriad", Triple::Myriad)
409 .Default(Triple::UnknownVendor);
412 static Triple::OSType parseOS(StringRef OSName) {
413 return StringSwitch<Triple::OSType>(OSName)
414 .StartsWith("cloudabi", Triple::CloudABI)
415 .StartsWith("darwin", Triple::Darwin)
416 .StartsWith("dragonfly", Triple::DragonFly)
417 .StartsWith("freebsd", Triple::FreeBSD)
418 .StartsWith("ios", Triple::IOS)
419 .StartsWith("kfreebsd", Triple::KFreeBSD)
420 .StartsWith("linux", Triple::Linux)
421 .StartsWith("lv2", Triple::Lv2)
422 .StartsWith("macosx", Triple::MacOSX)
423 .StartsWith("netbsd", Triple::NetBSD)
424 .StartsWith("openbsd", Triple::OpenBSD)
425 .StartsWith("solaris", Triple::Solaris)
426 .StartsWith("win32", Triple::Win32)
427 .StartsWith("windows", Triple::Win32)
428 .StartsWith("haiku", Triple::Haiku)
429 .StartsWith("minix", Triple::Minix)
430 .StartsWith("rtems", Triple::RTEMS)
431 .StartsWith("nacl", Triple::NaCl)
432 .StartsWith("cnk", Triple::CNK)
433 .StartsWith("bitrig", Triple::Bitrig)
434 .StartsWith("aix", Triple::AIX)
435 .StartsWith("cuda", Triple::CUDA)
436 .StartsWith("nvcl", Triple::NVCL)
437 .StartsWith("amdhsa", Triple::AMDHSA)
438 .StartsWith("ps4", Triple::PS4)
439 .StartsWith("elfiamcu", Triple::ELFIAMCU)
440 .Default(Triple::UnknownOS);
443 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
444 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
445 .StartsWith("eabihf", Triple::EABIHF)
446 .StartsWith("eabi", Triple::EABI)
447 .StartsWith("gnueabihf", Triple::GNUEABIHF)
448 .StartsWith("gnueabi", Triple::GNUEABI)
449 .StartsWith("gnux32", Triple::GNUX32)
450 .StartsWith("code16", Triple::CODE16)
451 .StartsWith("gnu", Triple::GNU)
452 .StartsWith("android", Triple::Android)
453 .StartsWith("msvc", Triple::MSVC)
454 .StartsWith("itanium", Triple::Itanium)
455 .StartsWith("cygnus", Triple::Cygnus)
456 .StartsWith("amdopencl", Triple::AMDOpenCL)
457 .StartsWith("coreclr", Triple::CoreCLR)
458 .Default(Triple::UnknownEnvironment);
461 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
462 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
463 .EndsWith("coff", Triple::COFF)
464 .EndsWith("elf", Triple::ELF)
465 .EndsWith("macho", Triple::MachO)
466 .Default(Triple::UnknownObjectFormat);
469 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
470 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
472 // For now, this is the small part. Early return.
473 if (ARMSubArch.empty())
474 return StringSwitch<Triple::SubArchType>(SubArchName)
475 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
476 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
477 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
478 .Default(Triple::NoSubArch);
481 switch(ARM::parseArch(ARMSubArch)) {
483 return Triple::NoSubArch;
485 return Triple::ARMSubArch_v4t;
489 return Triple::ARMSubArch_v5;
490 case ARM::AK_ARMV5TE:
492 case ARM::AK_IWMMXT2:
494 case ARM::AK_ARMV5TEJ:
495 return Triple::ARMSubArch_v5te;
499 return Triple::ARMSubArch_v6;
501 case ARM::AK_ARMV6ZK:
502 case ARM::AK_ARMV6HL:
503 return Triple::ARMSubArch_v6k;
504 case ARM::AK_ARMV6T2:
505 return Triple::ARMSubArch_v6t2;
507 case ARM::AK_ARMV6SM:
508 return Triple::ARMSubArch_v6m;
513 case ARM::AK_ARMV7HL:
514 return Triple::ARMSubArch_v7;
516 return Triple::ARMSubArch_v7m;
518 return Triple::ARMSubArch_v7s;
519 case ARM::AK_ARMV7EM:
520 return Triple::ARMSubArch_v7em;
522 return Triple::ARMSubArch_v8;
523 case ARM::AK_ARMV8_1A:
524 return Triple::ARMSubArch_v8_1a;
526 return Triple::NoSubArch;
530 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
532 case Triple::UnknownObjectFormat: return "";
533 case Triple::COFF: return "coff";
534 case Triple::ELF: return "elf";
535 case Triple::MachO: return "macho";
537 llvm_unreachable("unknown object format type");
540 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
541 switch (T.getArch()) {
544 case Triple::hexagon:
548 case Triple::mips64el:
552 case Triple::sparcv9:
553 case Triple::systemz:
555 case Triple::ppc64le:
561 return Triple::MachO;
566 // Unknown for now, until an object format is specified.
567 return Triple::UnknownObjectFormat;
571 return Triple::MachO;
572 else if (T.isOSWindows())
577 /// \brief Construct a triple from the string representation provided.
579 /// This stores the string representation and parses the various pieces into
581 Triple::Triple(const Twine &Str)
582 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
583 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
584 ObjectFormat(UnknownObjectFormat) {
585 // Do minimal parsing by hand here.
586 SmallVector<StringRef, 4> Components;
587 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
588 if (Components.size() > 0) {
589 Arch = parseArch(Components[0]);
590 SubArch = parseSubArch(Components[0]);
591 if (Components.size() > 1) {
592 Vendor = parseVendor(Components[1]);
593 if (Components.size() > 2) {
594 OS = parseOS(Components[2]);
595 if (Components.size() > 3) {
596 Environment = parseEnvironment(Components[3]);
597 ObjectFormat = parseFormat(Components[3]);
602 if (ObjectFormat == UnknownObjectFormat)
603 ObjectFormat = getDefaultFormat(*this);
606 /// \brief Construct a triple from string representations of the architecture,
609 /// This joins each argument into a canonical string representation and parses
610 /// them into enum members. It leaves the environment unknown and omits it from
611 /// the string representation.
612 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
613 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
614 Arch(parseArch(ArchStr.str())),
615 SubArch(parseSubArch(ArchStr.str())),
616 Vendor(parseVendor(VendorStr.str())),
617 OS(parseOS(OSStr.str())),
618 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
619 ObjectFormat = getDefaultFormat(*this);
622 /// \brief Construct a triple from string representations of the architecture,
623 /// vendor, OS, and environment.
625 /// This joins each argument into a canonical string representation and parses
626 /// them into enum members.
627 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
628 const Twine &EnvironmentStr)
629 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
630 EnvironmentStr).str()),
631 Arch(parseArch(ArchStr.str())),
632 SubArch(parseSubArch(ArchStr.str())),
633 Vendor(parseVendor(VendorStr.str())),
634 OS(parseOS(OSStr.str())),
635 Environment(parseEnvironment(EnvironmentStr.str())),
636 ObjectFormat(parseFormat(EnvironmentStr.str())) {
637 if (ObjectFormat == Triple::UnknownObjectFormat)
638 ObjectFormat = getDefaultFormat(*this);
641 std::string Triple::normalize(StringRef Str) {
642 bool IsMinGW32 = false;
643 bool IsCygwin = false;
645 // Parse into components.
646 SmallVector<StringRef, 4> Components;
647 Str.split(Components, '-');
649 // If the first component corresponds to a known architecture, preferentially
650 // use it for the architecture. If the second component corresponds to a
651 // known vendor, preferentially use it for the vendor, etc. This avoids silly
652 // component movement when a component parses as (eg) both a valid arch and a
654 ArchType Arch = UnknownArch;
655 if (Components.size() > 0)
656 Arch = parseArch(Components[0]);
657 VendorType Vendor = UnknownVendor;
658 if (Components.size() > 1)
659 Vendor = parseVendor(Components[1]);
660 OSType OS = UnknownOS;
661 if (Components.size() > 2) {
662 OS = parseOS(Components[2]);
663 IsCygwin = Components[2].startswith("cygwin");
664 IsMinGW32 = Components[2].startswith("mingw");
666 EnvironmentType Environment = UnknownEnvironment;
667 if (Components.size() > 3)
668 Environment = parseEnvironment(Components[3]);
669 ObjectFormatType ObjectFormat = UnknownObjectFormat;
670 if (Components.size() > 4)
671 ObjectFormat = parseFormat(Components[4]);
673 // Note which components are already in their final position. These will not
676 Found[0] = Arch != UnknownArch;
677 Found[1] = Vendor != UnknownVendor;
678 Found[2] = OS != UnknownOS;
679 Found[3] = Environment != UnknownEnvironment;
681 // If they are not there already, permute the components into their canonical
682 // positions by seeing if they parse as a valid architecture, and if so moving
683 // the component to the architecture position etc.
684 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
686 continue; // Already in the canonical position.
688 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
689 // Do not reparse any components that already matched.
690 if (Idx < array_lengthof(Found) && Found[Idx])
693 // Does this component parse as valid for the target position?
695 StringRef Comp = Components[Idx];
697 default: llvm_unreachable("unexpected component type!");
699 Arch = parseArch(Comp);
700 Valid = Arch != UnknownArch;
703 Vendor = parseVendor(Comp);
704 Valid = Vendor != UnknownVendor;
708 IsCygwin = Comp.startswith("cygwin");
709 IsMinGW32 = Comp.startswith("mingw");
710 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
713 Environment = parseEnvironment(Comp);
714 Valid = Environment != UnknownEnvironment;
716 ObjectFormat = parseFormat(Comp);
717 Valid = ObjectFormat != UnknownObjectFormat;
722 continue; // Nope, try the next component.
724 // Move the component to the target position, pushing any non-fixed
725 // components that are in the way to the right. This tends to give
726 // good results in the common cases of a forgotten vendor component
727 // or a wrongly positioned environment.
729 // Insert left, pushing the existing components to the right. For
730 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
731 StringRef CurrentComponent(""); // The empty component.
732 // Replace the component we are moving with an empty component.
733 std::swap(CurrentComponent, Components[Idx]);
734 // Insert the component being moved at Pos, displacing any existing
735 // components to the right.
736 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
737 // Skip over any fixed components.
738 while (i < array_lengthof(Found) && Found[i])
740 // Place the component at the new position, getting the component
741 // that was at this position - it will be moved right.
742 std::swap(CurrentComponent, Components[i]);
744 } else if (Pos > Idx) {
745 // Push right by inserting empty components until the component at Idx
746 // reaches the target position Pos. For example, pc-a -> -pc-a when
747 // moving pc to the second position.
749 // Insert one empty component at Idx.
750 StringRef CurrentComponent(""); // The empty component.
751 for (unsigned i = Idx; i < Components.size();) {
752 // Place the component at the new position, getting the component
753 // that was at this position - it will be moved right.
754 std::swap(CurrentComponent, Components[i]);
755 // If it was placed on top of an empty component then we are done.
756 if (CurrentComponent.empty())
758 // Advance to the next component, skipping any fixed components.
759 while (++i < array_lengthof(Found) && Found[i])
762 // The last component was pushed off the end - append it.
763 if (!CurrentComponent.empty())
764 Components.push_back(CurrentComponent);
766 // Advance Idx to the component's new position.
767 while (++Idx < array_lengthof(Found) && Found[Idx])
769 } while (Idx < Pos); // Add more until the final position is reached.
771 assert(Pos < Components.size() && Components[Pos] == Comp &&
772 "Component moved wrong!");
778 // Special case logic goes here. At this point Arch, Vendor and OS have the
779 // correct values for the computed components.
780 std::string NormalizedEnvironment;
781 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
782 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
783 if (AndroidVersion.empty()) {
784 Components[3] = "android";
786 NormalizedEnvironment = Twine("android", AndroidVersion).str();
787 Components[3] = NormalizedEnvironment;
791 if (OS == Triple::Win32) {
792 Components.resize(4);
793 Components[2] = "windows";
794 if (Environment == UnknownEnvironment) {
795 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
796 Components[3] = "msvc";
798 Components[3] = getObjectFormatTypeName(ObjectFormat);
800 } else if (IsMinGW32) {
801 Components.resize(4);
802 Components[2] = "windows";
803 Components[3] = "gnu";
804 } else if (IsCygwin) {
805 Components.resize(4);
806 Components[2] = "windows";
807 Components[3] = "cygnus";
809 if (IsMinGW32 || IsCygwin ||
810 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
811 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
812 Components.resize(5);
813 Components[4] = getObjectFormatTypeName(ObjectFormat);
817 // Stick the corrected components back together to form the normalized string.
818 std::string Normalized;
819 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
820 if (i) Normalized += '-';
821 Normalized += Components[i];
826 StringRef Triple::getArchName() const {
827 return StringRef(Data).split('-').first; // Isolate first component
830 StringRef Triple::getVendorName() const {
831 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
832 return Tmp.split('-').first; // Isolate second component
835 StringRef Triple::getOSName() const {
836 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
837 Tmp = Tmp.split('-').second; // Strip second component
838 return Tmp.split('-').first; // Isolate third component
841 StringRef Triple::getEnvironmentName() const {
842 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
843 Tmp = Tmp.split('-').second; // Strip second component
844 return Tmp.split('-').second; // Strip third component
847 StringRef Triple::getOSAndEnvironmentName() const {
848 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
849 return Tmp.split('-').second; // Strip second component
852 static unsigned EatNumber(StringRef &Str) {
853 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
857 // Consume the leading digit.
858 Result = Result*10 + (Str[0] - '0');
862 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
867 static void parseVersionFromName(StringRef Name, unsigned &Major,
868 unsigned &Minor, unsigned &Micro) {
869 // Any unset version defaults to 0.
870 Major = Minor = Micro = 0;
872 // Parse up to three components.
873 unsigned *Components[3] = {&Major, &Minor, &Micro};
874 for (unsigned i = 0; i != 3; ++i) {
875 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
878 // Consume the leading number.
879 *Components[i] = EatNumber(Name);
881 // Consume the separator, if present.
882 if (Name.startswith("."))
883 Name = Name.substr(1);
887 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
888 unsigned &Micro) const {
889 StringRef EnvironmentName = getEnvironmentName();
890 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
891 if (EnvironmentName.startswith(EnvironmentTypeName))
892 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
894 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
897 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
898 unsigned &Micro) const {
899 StringRef OSName = getOSName();
900 // Assume that the OS portion of the triple starts with the canonical name.
901 StringRef OSTypeName = getOSTypeName(getOS());
902 if (OSName.startswith(OSTypeName))
903 OSName = OSName.substr(OSTypeName.size());
905 parseVersionFromName(OSName, Major, Minor, Micro);
908 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
909 unsigned &Micro) const {
910 getOSVersion(Major, Minor, Micro);
913 default: llvm_unreachable("unexpected OS for Darwin triple");
915 // Default to darwin8, i.e., MacOSX 10.4.
918 // Darwin version numbers are skewed from OS X versions.
935 // Ignore the version from the triple. This is only handled because the
936 // the clang driver combines OS X and IOS support into a common Darwin
937 // toolchain that wants to know the OS X version number even when targeting
947 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
948 unsigned &Micro) const {
950 default: llvm_unreachable("unexpected OS for Darwin triple");
953 // Ignore the version from the triple. This is only handled because the
954 // the clang driver combines OS X and IOS support into a common Darwin
955 // toolchain that wants to know the iOS version number even when targeting
962 getOSVersion(Major, Minor, Micro);
963 // Default to 5.0 (or 7.0 for arm64).
965 Major = (getArch() == aarch64) ? 7 : 5;
970 void Triple::setTriple(const Twine &Str) {
974 void Triple::setArch(ArchType Kind) {
975 setArchName(getArchTypeName(Kind));
978 void Triple::setVendor(VendorType Kind) {
979 setVendorName(getVendorTypeName(Kind));
982 void Triple::setOS(OSType Kind) {
983 setOSName(getOSTypeName(Kind));
986 void Triple::setEnvironment(EnvironmentType Kind) {
987 if (ObjectFormat == getDefaultFormat(*this))
988 return setEnvironmentName(getEnvironmentTypeName(Kind));
990 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
991 getObjectFormatTypeName(ObjectFormat)).str());
994 void Triple::setObjectFormat(ObjectFormatType Kind) {
995 if (Environment == UnknownEnvironment)
996 return setEnvironmentName(getObjectFormatTypeName(Kind));
998 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
999 getObjectFormatTypeName(Kind)).str());
1002 void Triple::setArchName(StringRef Str) {
1003 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1004 SmallString<64> Triple;
1007 Triple += getVendorName();
1009 Triple += getOSAndEnvironmentName();
1013 void Triple::setVendorName(StringRef Str) {
1014 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1017 void Triple::setOSName(StringRef Str) {
1018 if (hasEnvironment())
1019 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1020 "-" + getEnvironmentName());
1022 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1025 void Triple::setEnvironmentName(StringRef Str) {
1026 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1030 void Triple::setOSAndEnvironmentName(StringRef Str) {
1031 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1034 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1036 case llvm::Triple::UnknownArch:
1039 case llvm::Triple::avr:
1040 case llvm::Triple::msp430:
1043 case llvm::Triple::arm:
1044 case llvm::Triple::armeb:
1045 case llvm::Triple::hexagon:
1046 case llvm::Triple::le32:
1047 case llvm::Triple::mips:
1048 case llvm::Triple::mipsel:
1049 case llvm::Triple::nvptx:
1050 case llvm::Triple::ppc:
1051 case llvm::Triple::r600:
1052 case llvm::Triple::sparc:
1053 case llvm::Triple::sparcel:
1054 case llvm::Triple::tce:
1055 case llvm::Triple::thumb:
1056 case llvm::Triple::thumbeb:
1057 case llvm::Triple::x86:
1058 case llvm::Triple::xcore:
1059 case llvm::Triple::amdil:
1060 case llvm::Triple::hsail:
1061 case llvm::Triple::spir:
1062 case llvm::Triple::kalimba:
1063 case llvm::Triple::shave:
1064 case llvm::Triple::wasm32:
1067 case llvm::Triple::aarch64:
1068 case llvm::Triple::aarch64_be:
1069 case llvm::Triple::amdgcn:
1070 case llvm::Triple::bpfel:
1071 case llvm::Triple::bpfeb:
1072 case llvm::Triple::le64:
1073 case llvm::Triple::mips64:
1074 case llvm::Triple::mips64el:
1075 case llvm::Triple::nvptx64:
1076 case llvm::Triple::ppc64:
1077 case llvm::Triple::ppc64le:
1078 case llvm::Triple::sparcv9:
1079 case llvm::Triple::systemz:
1080 case llvm::Triple::x86_64:
1081 case llvm::Triple::amdil64:
1082 case llvm::Triple::hsail64:
1083 case llvm::Triple::spir64:
1084 case llvm::Triple::wasm64:
1087 llvm_unreachable("Invalid architecture value");
1090 bool Triple::isArch64Bit() const {
1091 return getArchPointerBitWidth(getArch()) == 64;
1094 bool Triple::isArch32Bit() const {
1095 return getArchPointerBitWidth(getArch()) == 32;
1098 bool Triple::isArch16Bit() const {
1099 return getArchPointerBitWidth(getArch()) == 16;
1102 Triple Triple::get32BitArchVariant() const {
1104 switch (getArch()) {
1105 case Triple::UnknownArch:
1106 case Triple::aarch64:
1107 case Triple::aarch64_be:
1108 case Triple::amdgcn:
1112 case Triple::msp430:
1113 case Triple::systemz:
1114 case Triple::ppc64le:
1115 T.setArch(UnknownArch);
1123 case Triple::hexagon:
1124 case Triple::kalimba:
1127 case Triple::mipsel:
1132 case Triple::sparcel:
1135 case Triple::thumbeb:
1139 case Triple::wasm32:
1143 case Triple::le64: T.setArch(Triple::le32); break;
1144 case Triple::mips64: T.setArch(Triple::mips); break;
1145 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1146 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1147 case Triple::ppc64: T.setArch(Triple::ppc); break;
1148 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1149 case Triple::x86_64: T.setArch(Triple::x86); break;
1150 case Triple::amdil64: T.setArch(Triple::amdil); break;
1151 case Triple::hsail64: T.setArch(Triple::hsail); break;
1152 case Triple::spir64: T.setArch(Triple::spir); break;
1153 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1158 Triple Triple::get64BitArchVariant() const {
1160 switch (getArch()) {
1161 case Triple::UnknownArch:
1165 case Triple::hexagon:
1166 case Triple::kalimba:
1167 case Triple::msp430:
1171 case Triple::thumbeb:
1173 case Triple::sparcel:
1175 T.setArch(UnknownArch);
1178 case Triple::aarch64:
1179 case Triple::aarch64_be:
1183 case Triple::amdil64:
1184 case Triple::amdgcn:
1185 case Triple::hsail64:
1186 case Triple::spir64:
1187 case Triple::mips64:
1188 case Triple::mips64el:
1189 case Triple::nvptx64:
1191 case Triple::ppc64le:
1192 case Triple::sparcv9:
1193 case Triple::systemz:
1194 case Triple::x86_64:
1195 case Triple::wasm64:
1199 case Triple::le32: T.setArch(Triple::le64); break;
1200 case Triple::mips: T.setArch(Triple::mips64); break;
1201 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1202 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1203 case Triple::ppc: T.setArch(Triple::ppc64); break;
1204 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1205 case Triple::x86: T.setArch(Triple::x86_64); break;
1206 case Triple::amdil: T.setArch(Triple::amdil64); break;
1207 case Triple::hsail: T.setArch(Triple::hsail64); break;
1208 case Triple::spir: T.setArch(Triple::spir64); break;
1209 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1214 Triple Triple::getBigEndianArchVariant() const {
1216 switch (getArch()) {
1217 case Triple::UnknownArch:
1218 case Triple::amdgcn:
1219 case Triple::amdil64:
1222 case Triple::hexagon:
1223 case Triple::hsail64:
1225 case Triple::kalimba:
1228 case Triple::msp430:
1229 case Triple::nvptx64:
1233 case Triple::spir64:
1235 case Triple::wasm32:
1236 case Triple::wasm64:
1238 case Triple::x86_64:
1241 // ARM is intentionally unsupported here, changing the architecture would
1242 // drop any arch suffixes.
1245 T.setArch(UnknownArch);
1248 case Triple::aarch64_be:
1251 case Triple::mips64:
1256 case Triple::sparcv9:
1257 case Triple::systemz:
1259 case Triple::thumbeb:
1260 // Already big endian.
1263 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1264 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1265 case Triple::mips64el:T.setArch(Triple::mips64); break;
1266 case Triple::mipsel: T.setArch(Triple::mips); break;
1267 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1268 case Triple::sparcel: T.setArch(Triple::sparc); break;
1273 Triple Triple::getLittleEndianArchVariant() const {
1275 switch (getArch()) {
1276 case Triple::UnknownArch:
1278 case Triple::sparcv9:
1279 case Triple::systemz:
1282 // ARM is intentionally unsupported here, changing the architecture would
1283 // drop any arch suffixes.
1285 case Triple::thumbeb:
1286 T.setArch(UnknownArch);
1289 case Triple::aarch64:
1290 case Triple::amdgcn:
1291 case Triple::amdil64:
1296 case Triple::hexagon:
1297 case Triple::hsail64:
1299 case Triple::kalimba:
1302 case Triple::mips64el:
1303 case Triple::mipsel:
1304 case Triple::msp430:
1305 case Triple::nvptx64:
1307 case Triple::ppc64le:
1310 case Triple::sparcel:
1311 case Triple::spir64:
1314 case Triple::wasm32:
1315 case Triple::wasm64:
1317 case Triple::x86_64:
1319 // Already little endian.
1322 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1323 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1324 case Triple::mips64: T.setArch(Triple::mips64el); break;
1325 case Triple::mips: T.setArch(Triple::mipsel); break;
1326 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1327 case Triple::sparc: T.setArch(Triple::sparcel); break;
1332 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1334 MArch = getArchName();
1335 MArch = ARM::getCanonicalArchName(MArch);
1337 // Some defaults are forced.
1339 case llvm::Triple::FreeBSD:
1340 case llvm::Triple::NetBSD:
1341 if (!MArch.empty() && MArch == "v6")
1342 return "arm1176jzf-s";
1344 case llvm::Triple::Win32:
1345 // FIXME: this is invalid for WindowsCE
1354 StringRef CPU = ARM::getDefaultCPU(MArch);
1358 // If no specific architecture version is requested, return the minimum CPU
1359 // required by the OS and environment.
1361 case llvm::Triple::NetBSD:
1362 switch (getEnvironment()) {
1363 case llvm::Triple::GNUEABIHF:
1364 case llvm::Triple::GNUEABI:
1365 case llvm::Triple::EABIHF:
1366 case llvm::Triple::EABI:
1367 return "arm926ej-s";
1371 case llvm::Triple::NaCl:
1374 switch (getEnvironment()) {
1375 case llvm::Triple::EABIHF:
1376 case llvm::Triple::GNUEABIHF:
1377 return "arm1176jzf-s";
1383 llvm_unreachable("invalid arch name");