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)
575 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
576 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
577 ObjectFormat(UnknownObjectFormat) {
578 // Do minimal parsing by hand here.
579 SmallVector<StringRef, 4> Components;
580 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
581 if (Components.size() > 0) {
582 Arch = parseArch(Components[0]);
583 SubArch = parseSubArch(Components[0]);
584 if (Components.size() > 1) {
585 Vendor = parseVendor(Components[1]);
586 if (Components.size() > 2) {
587 OS = parseOS(Components[2]);
588 if (Components.size() > 3) {
589 Environment = parseEnvironment(Components[3]);
590 ObjectFormat = parseFormat(Components[3]);
595 if (ObjectFormat == UnknownObjectFormat)
596 ObjectFormat = getDefaultFormat(*this);
599 /// \brief Construct a triple from string representations of the architecture,
602 /// This joins each argument into a canonical string representation and parses
603 /// them into enum members. It leaves the environment unknown and omits it from
604 /// the string representation.
605 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
606 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
607 Arch(parseArch(ArchStr.str())),
608 SubArch(parseSubArch(ArchStr.str())),
609 Vendor(parseVendor(VendorStr.str())),
610 OS(parseOS(OSStr.str())),
611 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
612 ObjectFormat = getDefaultFormat(*this);
615 /// \brief Construct a triple from string representations of the architecture,
616 /// vendor, OS, and environment.
618 /// This joins each argument into a canonical string representation and parses
619 /// them into enum members.
620 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
621 const Twine &EnvironmentStr)
622 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
623 EnvironmentStr).str()),
624 Arch(parseArch(ArchStr.str())),
625 SubArch(parseSubArch(ArchStr.str())),
626 Vendor(parseVendor(VendorStr.str())),
627 OS(parseOS(OSStr.str())),
628 Environment(parseEnvironment(EnvironmentStr.str())),
629 ObjectFormat(parseFormat(EnvironmentStr.str())) {
630 if (ObjectFormat == Triple::UnknownObjectFormat)
631 ObjectFormat = getDefaultFormat(*this);
634 std::string Triple::normalize(StringRef Str) {
635 bool IsMinGW32 = false;
636 bool IsCygwin = false;
638 // Parse into components.
639 SmallVector<StringRef, 4> Components;
640 Str.split(Components, '-');
642 // If the first component corresponds to a known architecture, preferentially
643 // use it for the architecture. If the second component corresponds to a
644 // known vendor, preferentially use it for the vendor, etc. This avoids silly
645 // component movement when a component parses as (eg) both a valid arch and a
647 ArchType Arch = UnknownArch;
648 if (Components.size() > 0)
649 Arch = parseArch(Components[0]);
650 VendorType Vendor = UnknownVendor;
651 if (Components.size() > 1)
652 Vendor = parseVendor(Components[1]);
653 OSType OS = UnknownOS;
654 if (Components.size() > 2) {
655 OS = parseOS(Components[2]);
656 IsCygwin = Components[2].startswith("cygwin");
657 IsMinGW32 = Components[2].startswith("mingw");
659 EnvironmentType Environment = UnknownEnvironment;
660 if (Components.size() > 3)
661 Environment = parseEnvironment(Components[3]);
662 ObjectFormatType ObjectFormat = UnknownObjectFormat;
663 if (Components.size() > 4)
664 ObjectFormat = parseFormat(Components[4]);
666 // Note which components are already in their final position. These will not
669 Found[0] = Arch != UnknownArch;
670 Found[1] = Vendor != UnknownVendor;
671 Found[2] = OS != UnknownOS;
672 Found[3] = Environment != UnknownEnvironment;
674 // If they are not there already, permute the components into their canonical
675 // positions by seeing if they parse as a valid architecture, and if so moving
676 // the component to the architecture position etc.
677 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
679 continue; // Already in the canonical position.
681 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
682 // Do not reparse any components that already matched.
683 if (Idx < array_lengthof(Found) && Found[Idx])
686 // Does this component parse as valid for the target position?
688 StringRef Comp = Components[Idx];
690 default: llvm_unreachable("unexpected component type!");
692 Arch = parseArch(Comp);
693 Valid = Arch != UnknownArch;
696 Vendor = parseVendor(Comp);
697 Valid = Vendor != UnknownVendor;
701 IsCygwin = Comp.startswith("cygwin");
702 IsMinGW32 = Comp.startswith("mingw");
703 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
706 Environment = parseEnvironment(Comp);
707 Valid = Environment != UnknownEnvironment;
709 ObjectFormat = parseFormat(Comp);
710 Valid = ObjectFormat != UnknownObjectFormat;
715 continue; // Nope, try the next component.
717 // Move the component to the target position, pushing any non-fixed
718 // components that are in the way to the right. This tends to give
719 // good results in the common cases of a forgotten vendor component
720 // or a wrongly positioned environment.
722 // Insert left, pushing the existing components to the right. For
723 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
724 StringRef CurrentComponent(""); // The empty component.
725 // Replace the component we are moving with an empty component.
726 std::swap(CurrentComponent, Components[Idx]);
727 // Insert the component being moved at Pos, displacing any existing
728 // components to the right.
729 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
730 // Skip over any fixed components.
731 while (i < array_lengthof(Found) && Found[i])
733 // Place the component at the new position, getting the component
734 // that was at this position - it will be moved right.
735 std::swap(CurrentComponent, Components[i]);
737 } else if (Pos > Idx) {
738 // Push right by inserting empty components until the component at Idx
739 // reaches the target position Pos. For example, pc-a -> -pc-a when
740 // moving pc to the second position.
742 // Insert one empty component at Idx.
743 StringRef CurrentComponent(""); // The empty component.
744 for (unsigned i = Idx; i < Components.size();) {
745 // Place the component at the new position, getting the component
746 // that was at this position - it will be moved right.
747 std::swap(CurrentComponent, Components[i]);
748 // If it was placed on top of an empty component then we are done.
749 if (CurrentComponent.empty())
751 // Advance to the next component, skipping any fixed components.
752 while (++i < array_lengthof(Found) && Found[i])
755 // The last component was pushed off the end - append it.
756 if (!CurrentComponent.empty())
757 Components.push_back(CurrentComponent);
759 // Advance Idx to the component's new position.
760 while (++Idx < array_lengthof(Found) && Found[Idx])
762 } while (Idx < Pos); // Add more until the final position is reached.
764 assert(Pos < Components.size() && Components[Pos] == Comp &&
765 "Component moved wrong!");
771 // Special case logic goes here. At this point Arch, Vendor and OS have the
772 // correct values for the computed components.
773 std::string NormalizedEnvironment;
774 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
775 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
776 if (AndroidVersion.empty()) {
777 Components[3] = "android";
779 NormalizedEnvironment = Twine("android", AndroidVersion).str();
780 Components[3] = NormalizedEnvironment;
784 if (OS == Triple::Win32) {
785 Components.resize(4);
786 Components[2] = "windows";
787 if (Environment == UnknownEnvironment) {
788 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
789 Components[3] = "msvc";
791 Components[3] = getObjectFormatTypeName(ObjectFormat);
793 } else if (IsMinGW32) {
794 Components.resize(4);
795 Components[2] = "windows";
796 Components[3] = "gnu";
797 } else if (IsCygwin) {
798 Components.resize(4);
799 Components[2] = "windows";
800 Components[3] = "cygnus";
802 if (IsMinGW32 || IsCygwin ||
803 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
804 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
805 Components.resize(5);
806 Components[4] = getObjectFormatTypeName(ObjectFormat);
810 // Stick the corrected components back together to form the normalized string.
811 std::string Normalized;
812 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
813 if (i) Normalized += '-';
814 Normalized += Components[i];
819 StringRef Triple::getArchName() const {
820 return StringRef(Data).split('-').first; // Isolate first component
823 StringRef Triple::getVendorName() const {
824 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
825 return Tmp.split('-').first; // Isolate second component
828 StringRef Triple::getOSName() const {
829 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
830 Tmp = Tmp.split('-').second; // Strip second component
831 return Tmp.split('-').first; // Isolate third component
834 StringRef Triple::getEnvironmentName() const {
835 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
836 Tmp = Tmp.split('-').second; // Strip second component
837 return Tmp.split('-').second; // Strip third component
840 StringRef Triple::getOSAndEnvironmentName() const {
841 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
842 return Tmp.split('-').second; // Strip second component
845 static unsigned EatNumber(StringRef &Str) {
846 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
850 // Consume the leading digit.
851 Result = Result*10 + (Str[0] - '0');
855 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
860 static void parseVersionFromName(StringRef Name, unsigned &Major,
861 unsigned &Minor, unsigned &Micro) {
862 // Any unset version defaults to 0.
863 Major = Minor = Micro = 0;
865 // Parse up to three components.
866 unsigned *Components[3] = {&Major, &Minor, &Micro};
867 for (unsigned i = 0; i != 3; ++i) {
868 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
871 // Consume the leading number.
872 *Components[i] = EatNumber(Name);
874 // Consume the separator, if present.
875 if (Name.startswith("."))
876 Name = Name.substr(1);
880 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
881 unsigned &Micro) const {
882 StringRef EnvironmentName = getEnvironmentName();
883 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
884 if (EnvironmentName.startswith(EnvironmentTypeName))
885 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
887 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
890 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
891 unsigned &Micro) const {
892 StringRef OSName = getOSName();
893 // Assume that the OS portion of the triple starts with the canonical name.
894 StringRef OSTypeName = getOSTypeName(getOS());
895 if (OSName.startswith(OSTypeName))
896 OSName = OSName.substr(OSTypeName.size());
898 parseVersionFromName(OSName, Major, Minor, Micro);
901 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
902 unsigned &Micro) const {
903 getOSVersion(Major, Minor, Micro);
906 default: llvm_unreachable("unexpected OS for Darwin triple");
908 // Default to darwin8, i.e., MacOSX 10.4.
911 // Darwin version numbers are skewed from OS X versions.
928 // Ignore the version from the triple. This is only handled because the
929 // the clang driver combines OS X and IOS support into a common Darwin
930 // toolchain that wants to know the OS X version number even when targeting
940 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
941 unsigned &Micro) const {
943 default: llvm_unreachable("unexpected OS for Darwin triple");
946 // Ignore the version from the triple. This is only handled because the
947 // the clang driver combines OS X and IOS support into a common Darwin
948 // toolchain that wants to know the iOS version number even when targeting
955 getOSVersion(Major, Minor, Micro);
956 // Default to 5.0 (or 7.0 for arm64).
958 Major = (getArch() == aarch64) ? 7 : 5;
963 void Triple::setTriple(const Twine &Str) {
967 void Triple::setArch(ArchType Kind) {
968 setArchName(getArchTypeName(Kind));
971 void Triple::setVendor(VendorType Kind) {
972 setVendorName(getVendorTypeName(Kind));
975 void Triple::setOS(OSType Kind) {
976 setOSName(getOSTypeName(Kind));
979 void Triple::setEnvironment(EnvironmentType Kind) {
980 if (ObjectFormat == getDefaultFormat(*this))
981 return setEnvironmentName(getEnvironmentTypeName(Kind));
983 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
984 getObjectFormatTypeName(ObjectFormat)).str());
987 void Triple::setObjectFormat(ObjectFormatType Kind) {
988 if (Environment == UnknownEnvironment)
989 return setEnvironmentName(getObjectFormatTypeName(Kind));
991 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
992 getObjectFormatTypeName(Kind)).str());
995 void Triple::setArchName(StringRef Str) {
996 // Work around a miscompilation bug for Twines in gcc 4.0.3.
997 SmallString<64> Triple;
1000 Triple += getVendorName();
1002 Triple += getOSAndEnvironmentName();
1006 void Triple::setVendorName(StringRef Str) {
1007 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1010 void Triple::setOSName(StringRef Str) {
1011 if (hasEnvironment())
1012 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1013 "-" + getEnvironmentName());
1015 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1018 void Triple::setEnvironmentName(StringRef Str) {
1019 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1023 void Triple::setOSAndEnvironmentName(StringRef Str) {
1024 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1027 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1029 case llvm::Triple::UnknownArch:
1032 case llvm::Triple::msp430:
1035 case llvm::Triple::arm:
1036 case llvm::Triple::armeb:
1037 case llvm::Triple::hexagon:
1038 case llvm::Triple::le32:
1039 case llvm::Triple::mips:
1040 case llvm::Triple::mipsel:
1041 case llvm::Triple::nvptx:
1042 case llvm::Triple::ppc:
1043 case llvm::Triple::r600:
1044 case llvm::Triple::sparc:
1045 case llvm::Triple::sparcel:
1046 case llvm::Triple::tce:
1047 case llvm::Triple::thumb:
1048 case llvm::Triple::thumbeb:
1049 case llvm::Triple::x86:
1050 case llvm::Triple::xcore:
1051 case llvm::Triple::amdil:
1052 case llvm::Triple::hsail:
1053 case llvm::Triple::spir:
1054 case llvm::Triple::kalimba:
1055 case llvm::Triple::shave:
1056 case llvm::Triple::wasm32:
1059 case llvm::Triple::aarch64:
1060 case llvm::Triple::aarch64_be:
1061 case llvm::Triple::amdgcn:
1062 case llvm::Triple::bpfel:
1063 case llvm::Triple::bpfeb:
1064 case llvm::Triple::le64:
1065 case llvm::Triple::mips64:
1066 case llvm::Triple::mips64el:
1067 case llvm::Triple::nvptx64:
1068 case llvm::Triple::ppc64:
1069 case llvm::Triple::ppc64le:
1070 case llvm::Triple::sparcv9:
1071 case llvm::Triple::systemz:
1072 case llvm::Triple::x86_64:
1073 case llvm::Triple::amdil64:
1074 case llvm::Triple::hsail64:
1075 case llvm::Triple::spir64:
1076 case llvm::Triple::wasm64:
1079 llvm_unreachable("Invalid architecture value");
1082 bool Triple::isArch64Bit() const {
1083 return getArchPointerBitWidth(getArch()) == 64;
1086 bool Triple::isArch32Bit() const {
1087 return getArchPointerBitWidth(getArch()) == 32;
1090 bool Triple::isArch16Bit() const {
1091 return getArchPointerBitWidth(getArch()) == 16;
1094 Triple Triple::get32BitArchVariant() const {
1096 switch (getArch()) {
1097 case Triple::UnknownArch:
1098 case Triple::aarch64:
1099 case Triple::aarch64_be:
1100 case Triple::amdgcn:
1103 case Triple::msp430:
1104 case Triple::systemz:
1105 case Triple::ppc64le:
1106 T.setArch(UnknownArch);
1114 case Triple::hexagon:
1115 case Triple::kalimba:
1118 case Triple::mipsel:
1123 case Triple::sparcel:
1126 case Triple::thumbeb:
1130 case Triple::wasm32:
1134 case Triple::le64: T.setArch(Triple::le32); break;
1135 case Triple::mips64: T.setArch(Triple::mips); break;
1136 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1137 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1138 case Triple::ppc64: T.setArch(Triple::ppc); break;
1139 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1140 case Triple::x86_64: T.setArch(Triple::x86); break;
1141 case Triple::amdil64: T.setArch(Triple::amdil); break;
1142 case Triple::hsail64: T.setArch(Triple::hsail); break;
1143 case Triple::spir64: T.setArch(Triple::spir); break;
1144 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1149 Triple Triple::get64BitArchVariant() const {
1151 switch (getArch()) {
1152 case Triple::UnknownArch:
1155 case Triple::hexagon:
1156 case Triple::kalimba:
1157 case Triple::msp430:
1161 case Triple::thumbeb:
1163 case Triple::sparcel:
1165 T.setArch(UnknownArch);
1168 case Triple::aarch64:
1169 case Triple::aarch64_be:
1173 case Triple::amdil64:
1174 case Triple::amdgcn:
1175 case Triple::hsail64:
1176 case Triple::spir64:
1177 case Triple::mips64:
1178 case Triple::mips64el:
1179 case Triple::nvptx64:
1181 case Triple::ppc64le:
1182 case Triple::sparcv9:
1183 case Triple::systemz:
1184 case Triple::x86_64:
1185 case Triple::wasm64:
1189 case Triple::le32: T.setArch(Triple::le64); break;
1190 case Triple::mips: T.setArch(Triple::mips64); break;
1191 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1192 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1193 case Triple::ppc: T.setArch(Triple::ppc64); break;
1194 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1195 case Triple::x86: T.setArch(Triple::x86_64); break;
1196 case Triple::amdil: T.setArch(Triple::amdil64); break;
1197 case Triple::hsail: T.setArch(Triple::hsail64); break;
1198 case Triple::spir: T.setArch(Triple::spir64); break;
1199 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1204 Triple Triple::getBigEndianArchVariant() const {
1206 switch (getArch()) {
1207 case Triple::UnknownArch:
1208 case Triple::amdgcn:
1209 case Triple::amdil64:
1211 case Triple::hexagon:
1212 case Triple::hsail64:
1214 case Triple::kalimba:
1217 case Triple::msp430:
1218 case Triple::nvptx64:
1222 case Triple::spir64:
1224 case Triple::wasm32:
1225 case Triple::wasm64:
1227 case Triple::x86_64:
1230 // ARM is intentionally unsupported here, changing the architecture would
1231 // drop any arch suffixes.
1234 T.setArch(UnknownArch);
1237 case Triple::aarch64_be:
1240 case Triple::mips64:
1245 case Triple::sparcv9:
1246 case Triple::systemz:
1248 case Triple::thumbeb:
1249 // Already big endian.
1252 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1253 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1254 case Triple::mips64el:T.setArch(Triple::mips64); break;
1255 case Triple::mipsel: T.setArch(Triple::mips); break;
1256 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1257 case Triple::sparcel: T.setArch(Triple::sparc); break;
1262 Triple Triple::getLittleEndianArchVariant() const {
1264 switch (getArch()) {
1265 case Triple::UnknownArch:
1267 case Triple::sparcv9:
1268 case Triple::systemz:
1271 // ARM is intentionally unsupported here, changing the architecture would
1272 // drop any arch suffixes.
1274 case Triple::thumbeb:
1275 T.setArch(UnknownArch);
1278 case Triple::aarch64:
1279 case Triple::amdgcn:
1280 case Triple::amdil64:
1284 case Triple::hexagon:
1285 case Triple::hsail64:
1287 case Triple::kalimba:
1290 case Triple::mips64el:
1291 case Triple::mipsel:
1292 case Triple::msp430:
1293 case Triple::nvptx64:
1295 case Triple::ppc64le:
1298 case Triple::sparcel:
1299 case Triple::spir64:
1302 case Triple::wasm32:
1303 case Triple::wasm64:
1305 case Triple::x86_64:
1307 // Already little endian.
1310 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1311 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1312 case Triple::mips64: T.setArch(Triple::mips64el); break;
1313 case Triple::mips: T.setArch(Triple::mipsel); break;
1314 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1315 case Triple::sparc: T.setArch(Triple::sparcel); break;
1320 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1322 MArch = getArchName();
1323 MArch = ARM::getCanonicalArchName(MArch);
1325 // Some defaults are forced.
1327 case llvm::Triple::FreeBSD:
1328 case llvm::Triple::NetBSD:
1329 if (!MArch.empty() && MArch == "v6")
1330 return "arm1176jzf-s";
1332 case llvm::Triple::Win32:
1333 // FIXME: this is invalid for WindowsCE
1342 StringRef CPU = ARM::getDefaultCPU(MArch);
1346 // If no specific architecture version is requested, return the minimum CPU
1347 // required by the OS and environment.
1349 case llvm::Triple::NetBSD:
1350 switch (getEnvironment()) {
1351 case llvm::Triple::GNUEABIHF:
1352 case llvm::Triple::GNUEABI:
1353 case llvm::Triple::EABIHF:
1354 case llvm::Triple::EABI:
1355 return "arm926ej-s";
1359 case llvm::Triple::NaCl:
1362 switch (getEnvironment()) {
1363 case llvm::Triple::EABIHF:
1364 case llvm::Triple::GNUEABIHF:
1365 return "arm1176jzf-s";
1371 llvm_unreachable("invalid arch name");