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";
185 case TvOS: return "tvos";
186 case WatchOS: return "watchos";
189 llvm_unreachable("Invalid OSType");
192 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
194 case UnknownEnvironment: return "unknown";
195 case GNU: return "gnu";
196 case GNUEABIHF: return "gnueabihf";
197 case GNUEABI: return "gnueabi";
198 case GNUX32: return "gnux32";
199 case CODE16: return "code16";
200 case EABI: return "eabi";
201 case EABIHF: return "eabihf";
202 case Android: return "android";
203 case MSVC: return "msvc";
204 case Itanium: return "itanium";
205 case Cygnus: return "cygnus";
206 case AMDOpenCL: return "amdopencl";
207 case CoreCLR: return "coreclr";
210 llvm_unreachable("Invalid EnvironmentType!");
213 static Triple::ArchType parseBPFArch(StringRef ArchName) {
214 if (ArchName.equals("bpf")) {
215 if (sys::IsLittleEndianHost)
216 return Triple::bpfel;
218 return Triple::bpfeb;
219 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
220 return Triple::bpfeb;
221 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
222 return Triple::bpfel;
224 return Triple::UnknownArch;
228 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
229 Triple::ArchType BPFArch(parseBPFArch(Name));
230 return StringSwitch<Triple::ArchType>(Name)
231 .Case("aarch64", aarch64)
232 .Case("aarch64_be", aarch64_be)
233 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
235 .Case("armeb", armeb)
237 .StartsWith("bpf", BPFArch)
239 .Case("mipsel", mipsel)
240 .Case("mips64", mips64)
241 .Case("mips64el", mips64el)
242 .Case("msp430", msp430)
243 .Case("ppc64", ppc64)
246 .Case("ppc64le", ppc64le)
248 .Case("amdgcn", amdgcn)
249 .Case("hexagon", hexagon)
250 .Case("sparc", sparc)
251 .Case("sparcel", sparcel)
252 .Case("sparcv9", sparcv9)
253 .Case("systemz", systemz)
255 .Case("thumb", thumb)
256 .Case("thumbeb", thumbeb)
258 .Case("x86-64", x86_64)
259 .Case("xcore", xcore)
260 .Case("nvptx", nvptx)
261 .Case("nvptx64", nvptx64)
264 .Case("amdil", amdil)
265 .Case("amdil64", amdil64)
266 .Case("hsail", hsail)
267 .Case("hsail64", hsail64)
269 .Case("spir64", spir64)
270 .Case("kalimba", kalimba)
271 .Case("shave", shave)
272 .Case("wasm32", wasm32)
273 .Case("wasm64", wasm64)
274 .Default(UnknownArch);
277 static Triple::ArchType parseARMArch(StringRef ArchName) {
278 unsigned ISA = ARM::parseArchISA(ArchName);
279 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
281 Triple::ArchType arch = Triple::UnknownArch;
283 case ARM::EK_LITTLE: {
289 arch = Triple::thumb;
291 case ARM::IK_AARCH64:
292 arch = Triple::aarch64;
300 arch = Triple::armeb;
303 arch = Triple::thumbeb;
305 case ARM::IK_AARCH64:
306 arch = Triple::aarch64_be;
313 ArchName = ARM::getCanonicalArchName(ArchName);
314 if (ArchName.empty())
315 return Triple::UnknownArch;
317 // Thumb only exists in v4+
318 if (ISA == ARM::IK_THUMB &&
319 (ArchName.startswith("v2") || ArchName.startswith("v3")))
320 return Triple::UnknownArch;
322 // Thumb only for v6m
323 unsigned Profile = ARM::parseArchProfile(ArchName);
324 unsigned Version = ARM::parseArchVersion(ArchName);
325 if (Profile == ARM::PK_M && Version == 6) {
326 if (ENDIAN == ARM::EK_BIG)
327 return Triple::thumbeb;
329 return Triple::thumb;
335 static Triple::ArchType parseArch(StringRef ArchName) {
336 auto AT = StringSwitch<Triple::ArchType>(ArchName)
337 .Cases("i386", "i486", "i586", "i686", Triple::x86)
338 // FIXME: Do we need to support these?
339 .Cases("i786", "i886", "i986", Triple::x86)
340 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
341 .Case("powerpc", Triple::ppc)
342 .Cases("powerpc64", "ppu", Triple::ppc64)
343 .Case("powerpc64le", Triple::ppc64le)
344 .Case("xscale", Triple::arm)
345 .Case("xscaleeb", Triple::armeb)
346 .Case("aarch64", Triple::aarch64)
347 .Case("aarch64_be", Triple::aarch64_be)
348 .Case("arm64", Triple::aarch64)
349 .Case("arm", Triple::arm)
350 .Case("armeb", Triple::armeb)
351 .Case("thumb", Triple::thumb)
352 .Case("thumbeb", Triple::thumbeb)
353 .Case("avr", Triple::avr)
354 .Case("msp430", Triple::msp430)
355 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
356 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
357 .Cases("mips64", "mips64eb", Triple::mips64)
358 .Case("mips64el", Triple::mips64el)
359 .Case("r600", Triple::r600)
360 .Case("amdgcn", Triple::amdgcn)
361 .Case("hexagon", Triple::hexagon)
362 .Case("s390x", Triple::systemz)
363 .Case("sparc", Triple::sparc)
364 .Case("sparcel", Triple::sparcel)
365 .Cases("sparcv9", "sparc64", Triple::sparcv9)
366 .Case("tce", Triple::tce)
367 .Case("xcore", Triple::xcore)
368 .Case("nvptx", Triple::nvptx)
369 .Case("nvptx64", Triple::nvptx64)
370 .Case("le32", Triple::le32)
371 .Case("le64", Triple::le64)
372 .Case("amdil", Triple::amdil)
373 .Case("amdil64", Triple::amdil64)
374 .Case("hsail", Triple::hsail)
375 .Case("hsail64", Triple::hsail64)
376 .Case("spir", Triple::spir)
377 .Case("spir64", Triple::spir64)
378 .StartsWith("kalimba", Triple::kalimba)
379 .Case("shave", Triple::shave)
380 .Case("wasm32", Triple::wasm32)
381 .Case("wasm64", Triple::wasm64)
382 .Default(Triple::UnknownArch);
384 // Some architectures require special parsing logic just to compute the
386 if (AT == Triple::UnknownArch) {
387 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
388 ArchName.startswith("aarch64"))
389 return parseARMArch(ArchName);
390 if (ArchName.startswith("bpf"))
391 return parseBPFArch(ArchName);
397 static Triple::VendorType parseVendor(StringRef VendorName) {
398 return StringSwitch<Triple::VendorType>(VendorName)
399 .Case("apple", Triple::Apple)
400 .Case("pc", Triple::PC)
401 .Case("scei", Triple::SCEI)
402 .Case("bgp", Triple::BGP)
403 .Case("bgq", Triple::BGQ)
404 .Case("fsl", Triple::Freescale)
405 .Case("ibm", Triple::IBM)
406 .Case("img", Triple::ImaginationTechnologies)
407 .Case("mti", Triple::MipsTechnologies)
408 .Case("nvidia", Triple::NVIDIA)
409 .Case("csr", Triple::CSR)
410 .Case("myriad", Triple::Myriad)
411 .Default(Triple::UnknownVendor);
414 static Triple::OSType parseOS(StringRef OSName) {
415 return StringSwitch<Triple::OSType>(OSName)
416 .StartsWith("cloudabi", Triple::CloudABI)
417 .StartsWith("darwin", Triple::Darwin)
418 .StartsWith("dragonfly", Triple::DragonFly)
419 .StartsWith("freebsd", Triple::FreeBSD)
420 .StartsWith("ios", Triple::IOS)
421 .StartsWith("kfreebsd", Triple::KFreeBSD)
422 .StartsWith("linux", Triple::Linux)
423 .StartsWith("lv2", Triple::Lv2)
424 .StartsWith("macosx", Triple::MacOSX)
425 .StartsWith("netbsd", Triple::NetBSD)
426 .StartsWith("openbsd", Triple::OpenBSD)
427 .StartsWith("solaris", Triple::Solaris)
428 .StartsWith("win32", Triple::Win32)
429 .StartsWith("windows", Triple::Win32)
430 .StartsWith("haiku", Triple::Haiku)
431 .StartsWith("minix", Triple::Minix)
432 .StartsWith("rtems", Triple::RTEMS)
433 .StartsWith("nacl", Triple::NaCl)
434 .StartsWith("cnk", Triple::CNK)
435 .StartsWith("bitrig", Triple::Bitrig)
436 .StartsWith("aix", Triple::AIX)
437 .StartsWith("cuda", Triple::CUDA)
438 .StartsWith("nvcl", Triple::NVCL)
439 .StartsWith("amdhsa", Triple::AMDHSA)
440 .StartsWith("ps4", Triple::PS4)
441 .StartsWith("elfiamcu", Triple::ELFIAMCU)
442 .StartsWith("tvos", Triple::TvOS)
443 .StartsWith("watchos", Triple::WatchOS)
444 .Default(Triple::UnknownOS);
447 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
448 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
449 .StartsWith("eabihf", Triple::EABIHF)
450 .StartsWith("eabi", Triple::EABI)
451 .StartsWith("gnueabihf", Triple::GNUEABIHF)
452 .StartsWith("gnueabi", Triple::GNUEABI)
453 .StartsWith("gnux32", Triple::GNUX32)
454 .StartsWith("code16", Triple::CODE16)
455 .StartsWith("gnu", Triple::GNU)
456 .StartsWith("android", Triple::Android)
457 .StartsWith("msvc", Triple::MSVC)
458 .StartsWith("itanium", Triple::Itanium)
459 .StartsWith("cygnus", Triple::Cygnus)
460 .StartsWith("amdopencl", Triple::AMDOpenCL)
461 .StartsWith("coreclr", Triple::CoreCLR)
462 .Default(Triple::UnknownEnvironment);
465 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
466 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
467 .EndsWith("coff", Triple::COFF)
468 .EndsWith("elf", Triple::ELF)
469 .EndsWith("macho", Triple::MachO)
470 .Default(Triple::UnknownObjectFormat);
473 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
474 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
476 // For now, this is the small part. Early return.
477 if (ARMSubArch.empty())
478 return StringSwitch<Triple::SubArchType>(SubArchName)
479 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
480 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
481 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
482 .Default(Triple::NoSubArch);
485 switch(ARM::parseArch(ARMSubArch)) {
487 return Triple::NoSubArch;
489 return Triple::ARMSubArch_v4t;
491 return Triple::ARMSubArch_v5;
492 case ARM::AK_ARMV5TE:
494 case ARM::AK_IWMMXT2:
496 case ARM::AK_ARMV5TEJ:
497 return Triple::ARMSubArch_v5te;
499 return Triple::ARMSubArch_v6;
501 case ARM::AK_ARMV6KZ:
502 return Triple::ARMSubArch_v6k;
503 case ARM::AK_ARMV6T2:
504 return Triple::ARMSubArch_v6t2;
506 return Triple::ARMSubArch_v6m;
509 return Triple::ARMSubArch_v7;
511 return Triple::ARMSubArch_v7k;
513 return Triple::ARMSubArch_v7m;
515 return Triple::ARMSubArch_v7s;
516 case ARM::AK_ARMV7EM:
517 return Triple::ARMSubArch_v7em;
519 return Triple::ARMSubArch_v8;
520 case ARM::AK_ARMV8_1A:
521 return Triple::ARMSubArch_v8_1a;
522 case ARM::AK_ARMV8_2A:
523 return Triple::ARMSubArch_v8_2a;
525 return Triple::NoSubArch;
529 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
531 case Triple::UnknownObjectFormat: return "";
532 case Triple::COFF: return "coff";
533 case Triple::ELF: return "elf";
534 case Triple::MachO: return "macho";
536 llvm_unreachable("unknown object format type");
539 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
540 switch (T.getArch()) {
543 case Triple::hexagon:
547 case Triple::mips64el:
551 case Triple::sparcv9:
552 case Triple::systemz:
554 case Triple::ppc64le:
560 return Triple::MachO;
565 // Unknown for now, until an object format is specified.
566 return Triple::UnknownObjectFormat;
570 return Triple::MachO;
571 else if (T.isOSWindows())
576 /// \brief Construct a triple from the string representation provided.
578 /// This stores the string representation and parses the various pieces into
580 Triple::Triple(const Twine &Str)
581 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
582 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
583 ObjectFormat(UnknownObjectFormat) {
584 // Do minimal parsing by hand here.
585 SmallVector<StringRef, 4> Components;
586 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
587 if (Components.size() > 0) {
588 Arch = parseArch(Components[0]);
589 SubArch = parseSubArch(Components[0]);
590 if (Components.size() > 1) {
591 Vendor = parseVendor(Components[1]);
592 if (Components.size() > 2) {
593 OS = parseOS(Components[2]);
594 if (Components.size() > 3) {
595 Environment = parseEnvironment(Components[3]);
596 ObjectFormat = parseFormat(Components[3]);
601 if (ObjectFormat == UnknownObjectFormat)
602 ObjectFormat = getDefaultFormat(*this);
605 /// \brief Construct a triple from string representations of the architecture,
608 /// This joins each argument into a canonical string representation and parses
609 /// them into enum members. It leaves the environment unknown and omits it from
610 /// the string representation.
611 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
612 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
613 Arch(parseArch(ArchStr.str())),
614 SubArch(parseSubArch(ArchStr.str())),
615 Vendor(parseVendor(VendorStr.str())),
616 OS(parseOS(OSStr.str())),
617 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
618 ObjectFormat = getDefaultFormat(*this);
621 /// \brief Construct a triple from string representations of the architecture,
622 /// vendor, OS, and environment.
624 /// This joins each argument into a canonical string representation and parses
625 /// them into enum members.
626 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
627 const Twine &EnvironmentStr)
628 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
629 EnvironmentStr).str()),
630 Arch(parseArch(ArchStr.str())),
631 SubArch(parseSubArch(ArchStr.str())),
632 Vendor(parseVendor(VendorStr.str())),
633 OS(parseOS(OSStr.str())),
634 Environment(parseEnvironment(EnvironmentStr.str())),
635 ObjectFormat(parseFormat(EnvironmentStr.str())) {
636 if (ObjectFormat == Triple::UnknownObjectFormat)
637 ObjectFormat = getDefaultFormat(*this);
640 std::string Triple::normalize(StringRef Str) {
641 bool IsMinGW32 = false;
642 bool IsCygwin = false;
644 // Parse into components.
645 SmallVector<StringRef, 4> Components;
646 Str.split(Components, '-');
648 // If the first component corresponds to a known architecture, preferentially
649 // use it for the architecture. If the second component corresponds to a
650 // known vendor, preferentially use it for the vendor, etc. This avoids silly
651 // component movement when a component parses as (eg) both a valid arch and a
653 ArchType Arch = UnknownArch;
654 if (Components.size() > 0)
655 Arch = parseArch(Components[0]);
656 VendorType Vendor = UnknownVendor;
657 if (Components.size() > 1)
658 Vendor = parseVendor(Components[1]);
659 OSType OS = UnknownOS;
660 if (Components.size() > 2) {
661 OS = parseOS(Components[2]);
662 IsCygwin = Components[2].startswith("cygwin");
663 IsMinGW32 = Components[2].startswith("mingw");
665 EnvironmentType Environment = UnknownEnvironment;
666 if (Components.size() > 3)
667 Environment = parseEnvironment(Components[3]);
668 ObjectFormatType ObjectFormat = UnknownObjectFormat;
669 if (Components.size() > 4)
670 ObjectFormat = parseFormat(Components[4]);
672 // Note which components are already in their final position. These will not
675 Found[0] = Arch != UnknownArch;
676 Found[1] = Vendor != UnknownVendor;
677 Found[2] = OS != UnknownOS;
678 Found[3] = Environment != UnknownEnvironment;
680 // If they are not there already, permute the components into their canonical
681 // positions by seeing if they parse as a valid architecture, and if so moving
682 // the component to the architecture position etc.
683 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
685 continue; // Already in the canonical position.
687 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
688 // Do not reparse any components that already matched.
689 if (Idx < array_lengthof(Found) && Found[Idx])
692 // Does this component parse as valid for the target position?
694 StringRef Comp = Components[Idx];
696 default: llvm_unreachable("unexpected component type!");
698 Arch = parseArch(Comp);
699 Valid = Arch != UnknownArch;
702 Vendor = parseVendor(Comp);
703 Valid = Vendor != UnknownVendor;
707 IsCygwin = Comp.startswith("cygwin");
708 IsMinGW32 = Comp.startswith("mingw");
709 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
712 Environment = parseEnvironment(Comp);
713 Valid = Environment != UnknownEnvironment;
715 ObjectFormat = parseFormat(Comp);
716 Valid = ObjectFormat != UnknownObjectFormat;
721 continue; // Nope, try the next component.
723 // Move the component to the target position, pushing any non-fixed
724 // components that are in the way to the right. This tends to give
725 // good results in the common cases of a forgotten vendor component
726 // or a wrongly positioned environment.
728 // Insert left, pushing the existing components to the right. For
729 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
730 StringRef CurrentComponent(""); // The empty component.
731 // Replace the component we are moving with an empty component.
732 std::swap(CurrentComponent, Components[Idx]);
733 // Insert the component being moved at Pos, displacing any existing
734 // components to the right.
735 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
736 // Skip over any fixed components.
737 while (i < array_lengthof(Found) && Found[i])
739 // Place the component at the new position, getting the component
740 // that was at this position - it will be moved right.
741 std::swap(CurrentComponent, Components[i]);
743 } else if (Pos > Idx) {
744 // Push right by inserting empty components until the component at Idx
745 // reaches the target position Pos. For example, pc-a -> -pc-a when
746 // moving pc to the second position.
748 // Insert one empty component at Idx.
749 StringRef CurrentComponent(""); // The empty component.
750 for (unsigned i = Idx; i < Components.size();) {
751 // Place the component at the new position, getting the component
752 // that was at this position - it will be moved right.
753 std::swap(CurrentComponent, Components[i]);
754 // If it was placed on top of an empty component then we are done.
755 if (CurrentComponent.empty())
757 // Advance to the next component, skipping any fixed components.
758 while (++i < array_lengthof(Found) && Found[i])
761 // The last component was pushed off the end - append it.
762 if (!CurrentComponent.empty())
763 Components.push_back(CurrentComponent);
765 // Advance Idx to the component's new position.
766 while (++Idx < array_lengthof(Found) && Found[Idx])
768 } while (Idx < Pos); // Add more until the final position is reached.
770 assert(Pos < Components.size() && Components[Pos] == Comp &&
771 "Component moved wrong!");
777 // Special case logic goes here. At this point Arch, Vendor and OS have the
778 // correct values for the computed components.
779 std::string NormalizedEnvironment;
780 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
781 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
782 if (AndroidVersion.empty()) {
783 Components[3] = "android";
785 NormalizedEnvironment = Twine("android", AndroidVersion).str();
786 Components[3] = NormalizedEnvironment;
790 if (OS == Triple::Win32) {
791 Components.resize(4);
792 Components[2] = "windows";
793 if (Environment == UnknownEnvironment) {
794 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
795 Components[3] = "msvc";
797 Components[3] = getObjectFormatTypeName(ObjectFormat);
799 } else if (IsMinGW32) {
800 Components.resize(4);
801 Components[2] = "windows";
802 Components[3] = "gnu";
803 } else if (IsCygwin) {
804 Components.resize(4);
805 Components[2] = "windows";
806 Components[3] = "cygnus";
808 if (IsMinGW32 || IsCygwin ||
809 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
810 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
811 Components.resize(5);
812 Components[4] = getObjectFormatTypeName(ObjectFormat);
816 // Stick the corrected components back together to form the normalized string.
817 std::string Normalized;
818 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
819 if (i) Normalized += '-';
820 Normalized += Components[i];
825 StringRef Triple::getArchName() const {
826 return StringRef(Data).split('-').first; // Isolate first component
829 StringRef Triple::getVendorName() const {
830 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
831 return Tmp.split('-').first; // Isolate second component
834 StringRef Triple::getOSName() const {
835 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
836 Tmp = Tmp.split('-').second; // Strip second component
837 return Tmp.split('-').first; // Isolate third component
840 StringRef Triple::getEnvironmentName() const {
841 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
842 Tmp = Tmp.split('-').second; // Strip second component
843 return Tmp.split('-').second; // Strip third component
846 StringRef Triple::getOSAndEnvironmentName() const {
847 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
848 return Tmp.split('-').second; // Strip second component
851 static unsigned EatNumber(StringRef &Str) {
852 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
856 // Consume the leading digit.
857 Result = Result*10 + (Str[0] - '0');
861 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
866 static void parseVersionFromName(StringRef Name, unsigned &Major,
867 unsigned &Minor, unsigned &Micro) {
868 // Any unset version defaults to 0.
869 Major = Minor = Micro = 0;
871 // Parse up to three components.
872 unsigned *Components[3] = {&Major, &Minor, &Micro};
873 for (unsigned i = 0; i != 3; ++i) {
874 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
877 // Consume the leading number.
878 *Components[i] = EatNumber(Name);
880 // Consume the separator, if present.
881 if (Name.startswith("."))
882 Name = Name.substr(1);
886 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
887 unsigned &Micro) const {
888 StringRef EnvironmentName = getEnvironmentName();
889 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
890 if (EnvironmentName.startswith(EnvironmentTypeName))
891 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
893 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
896 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
897 unsigned &Micro) const {
898 StringRef OSName = getOSName();
899 // Assume that the OS portion of the triple starts with the canonical name.
900 StringRef OSTypeName = getOSTypeName(getOS());
901 if (OSName.startswith(OSTypeName))
902 OSName = OSName.substr(OSTypeName.size());
904 parseVersionFromName(OSName, Major, Minor, Micro);
907 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
908 unsigned &Micro) const {
909 getOSVersion(Major, Minor, Micro);
912 default: llvm_unreachable("unexpected OS for Darwin triple");
914 // Default to darwin8, i.e., MacOSX 10.4.
917 // Darwin version numbers are skewed from OS X versions.
936 // Ignore the version from the triple. This is only handled because the
937 // the clang driver combines OS X and IOS support into a common Darwin
938 // toolchain that wants to know the OS X version number even when targeting
948 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
949 unsigned &Micro) const {
951 default: llvm_unreachable("unexpected OS for Darwin triple");
954 // Ignore the version from the triple. This is only handled because the
955 // the clang driver combines OS X and IOS support into a common Darwin
956 // toolchain that wants to know the iOS version number even when targeting
964 getOSVersion(Major, Minor, Micro);
965 // Default to 5.0 (or 7.0 for arm64).
967 Major = (getArch() == aarch64) ? 7 : 5;
970 llvm_unreachable("conflicting triple info");
974 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
975 unsigned &Micro) const {
977 default: llvm_unreachable("unexpected OS for Darwin triple");
980 // Ignore the version from the triple. This is only handled because the
981 // the clang driver combines OS X and IOS support into a common Darwin
982 // toolchain that wants to know the iOS version number even when targeting
989 getOSVersion(Major, Minor, Micro);
994 llvm_unreachable("conflicting triple info");
998 void Triple::setTriple(const Twine &Str) {
1002 void Triple::setArch(ArchType Kind) {
1003 setArchName(getArchTypeName(Kind));
1006 void Triple::setVendor(VendorType Kind) {
1007 setVendorName(getVendorTypeName(Kind));
1010 void Triple::setOS(OSType Kind) {
1011 setOSName(getOSTypeName(Kind));
1014 void Triple::setEnvironment(EnvironmentType Kind) {
1015 if (ObjectFormat == getDefaultFormat(*this))
1016 return setEnvironmentName(getEnvironmentTypeName(Kind));
1018 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1019 getObjectFormatTypeName(ObjectFormat)).str());
1022 void Triple::setObjectFormat(ObjectFormatType Kind) {
1023 if (Environment == UnknownEnvironment)
1024 return setEnvironmentName(getObjectFormatTypeName(Kind));
1026 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1027 getObjectFormatTypeName(Kind)).str());
1030 void Triple::setArchName(StringRef Str) {
1031 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1032 SmallString<64> Triple;
1035 Triple += getVendorName();
1037 Triple += getOSAndEnvironmentName();
1041 void Triple::setVendorName(StringRef Str) {
1042 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1045 void Triple::setOSName(StringRef Str) {
1046 if (hasEnvironment())
1047 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1048 "-" + getEnvironmentName());
1050 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1053 void Triple::setEnvironmentName(StringRef Str) {
1054 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1058 void Triple::setOSAndEnvironmentName(StringRef Str) {
1059 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1062 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1064 case llvm::Triple::UnknownArch:
1067 case llvm::Triple::avr:
1068 case llvm::Triple::msp430:
1071 case llvm::Triple::arm:
1072 case llvm::Triple::armeb:
1073 case llvm::Triple::hexagon:
1074 case llvm::Triple::le32:
1075 case llvm::Triple::mips:
1076 case llvm::Triple::mipsel:
1077 case llvm::Triple::nvptx:
1078 case llvm::Triple::ppc:
1079 case llvm::Triple::r600:
1080 case llvm::Triple::sparc:
1081 case llvm::Triple::sparcel:
1082 case llvm::Triple::tce:
1083 case llvm::Triple::thumb:
1084 case llvm::Triple::thumbeb:
1085 case llvm::Triple::x86:
1086 case llvm::Triple::xcore:
1087 case llvm::Triple::amdil:
1088 case llvm::Triple::hsail:
1089 case llvm::Triple::spir:
1090 case llvm::Triple::kalimba:
1091 case llvm::Triple::shave:
1092 case llvm::Triple::wasm32:
1095 case llvm::Triple::aarch64:
1096 case llvm::Triple::aarch64_be:
1097 case llvm::Triple::amdgcn:
1098 case llvm::Triple::bpfel:
1099 case llvm::Triple::bpfeb:
1100 case llvm::Triple::le64:
1101 case llvm::Triple::mips64:
1102 case llvm::Triple::mips64el:
1103 case llvm::Triple::nvptx64:
1104 case llvm::Triple::ppc64:
1105 case llvm::Triple::ppc64le:
1106 case llvm::Triple::sparcv9:
1107 case llvm::Triple::systemz:
1108 case llvm::Triple::x86_64:
1109 case llvm::Triple::amdil64:
1110 case llvm::Triple::hsail64:
1111 case llvm::Triple::spir64:
1112 case llvm::Triple::wasm64:
1115 llvm_unreachable("Invalid architecture value");
1118 bool Triple::isArch64Bit() const {
1119 return getArchPointerBitWidth(getArch()) == 64;
1122 bool Triple::isArch32Bit() const {
1123 return getArchPointerBitWidth(getArch()) == 32;
1126 bool Triple::isArch16Bit() const {
1127 return getArchPointerBitWidth(getArch()) == 16;
1130 Triple Triple::get32BitArchVariant() const {
1132 switch (getArch()) {
1133 case Triple::UnknownArch:
1134 case Triple::aarch64:
1135 case Triple::aarch64_be:
1136 case Triple::amdgcn:
1140 case Triple::msp430:
1141 case Triple::systemz:
1142 case Triple::ppc64le:
1143 T.setArch(UnknownArch);
1151 case Triple::hexagon:
1152 case Triple::kalimba:
1155 case Triple::mipsel:
1160 case Triple::sparcel:
1163 case Triple::thumbeb:
1167 case Triple::wasm32:
1171 case Triple::le64: T.setArch(Triple::le32); break;
1172 case Triple::mips64: T.setArch(Triple::mips); break;
1173 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1174 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1175 case Triple::ppc64: T.setArch(Triple::ppc); break;
1176 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1177 case Triple::x86_64: T.setArch(Triple::x86); break;
1178 case Triple::amdil64: T.setArch(Triple::amdil); break;
1179 case Triple::hsail64: T.setArch(Triple::hsail); break;
1180 case Triple::spir64: T.setArch(Triple::spir); break;
1181 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1186 Triple Triple::get64BitArchVariant() const {
1188 switch (getArch()) {
1189 case Triple::UnknownArch:
1193 case Triple::hexagon:
1194 case Triple::kalimba:
1195 case Triple::msp430:
1199 case Triple::thumbeb:
1201 case Triple::sparcel:
1203 T.setArch(UnknownArch);
1206 case Triple::aarch64:
1207 case Triple::aarch64_be:
1211 case Triple::amdil64:
1212 case Triple::amdgcn:
1213 case Triple::hsail64:
1214 case Triple::spir64:
1215 case Triple::mips64:
1216 case Triple::mips64el:
1217 case Triple::nvptx64:
1219 case Triple::ppc64le:
1220 case Triple::sparcv9:
1221 case Triple::systemz:
1222 case Triple::x86_64:
1223 case Triple::wasm64:
1227 case Triple::le32: T.setArch(Triple::le64); break;
1228 case Triple::mips: T.setArch(Triple::mips64); break;
1229 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1230 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1231 case Triple::ppc: T.setArch(Triple::ppc64); break;
1232 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1233 case Triple::x86: T.setArch(Triple::x86_64); break;
1234 case Triple::amdil: T.setArch(Triple::amdil64); break;
1235 case Triple::hsail: T.setArch(Triple::hsail64); break;
1236 case Triple::spir: T.setArch(Triple::spir64); break;
1237 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1242 Triple Triple::getBigEndianArchVariant() const {
1244 switch (getArch()) {
1245 case Triple::UnknownArch:
1246 case Triple::amdgcn:
1247 case Triple::amdil64:
1250 case Triple::hexagon:
1251 case Triple::hsail64:
1253 case Triple::kalimba:
1256 case Triple::msp430:
1257 case Triple::nvptx64:
1261 case Triple::spir64:
1263 case Triple::wasm32:
1264 case Triple::wasm64:
1266 case Triple::x86_64:
1269 // ARM is intentionally unsupported here, changing the architecture would
1270 // drop any arch suffixes.
1273 T.setArch(UnknownArch);
1276 case Triple::aarch64_be:
1279 case Triple::mips64:
1284 case Triple::sparcv9:
1285 case Triple::systemz:
1287 case Triple::thumbeb:
1288 // Already big endian.
1291 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1292 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1293 case Triple::mips64el:T.setArch(Triple::mips64); break;
1294 case Triple::mipsel: T.setArch(Triple::mips); break;
1295 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1296 case Triple::sparcel: T.setArch(Triple::sparc); break;
1301 Triple Triple::getLittleEndianArchVariant() const {
1303 switch (getArch()) {
1304 case Triple::UnknownArch:
1306 case Triple::sparcv9:
1307 case Triple::systemz:
1310 // ARM is intentionally unsupported here, changing the architecture would
1311 // drop any arch suffixes.
1313 case Triple::thumbeb:
1314 T.setArch(UnknownArch);
1317 case Triple::aarch64:
1318 case Triple::amdgcn:
1319 case Triple::amdil64:
1324 case Triple::hexagon:
1325 case Triple::hsail64:
1327 case Triple::kalimba:
1330 case Triple::mips64el:
1331 case Triple::mipsel:
1332 case Triple::msp430:
1333 case Triple::nvptx64:
1335 case Triple::ppc64le:
1338 case Triple::sparcel:
1339 case Triple::spir64:
1342 case Triple::wasm32:
1343 case Triple::wasm64:
1345 case Triple::x86_64:
1347 // Already little endian.
1350 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1351 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1352 case Triple::mips64: T.setArch(Triple::mips64el); break;
1353 case Triple::mips: T.setArch(Triple::mipsel); break;
1354 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1355 case Triple::sparc: T.setArch(Triple::sparcel); break;
1360 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1362 MArch = getArchName();
1363 MArch = ARM::getCanonicalArchName(MArch);
1365 // Some defaults are forced.
1367 case llvm::Triple::FreeBSD:
1368 case llvm::Triple::NetBSD:
1369 if (!MArch.empty() && MArch == "v6")
1370 return "arm1176jzf-s";
1372 case llvm::Triple::Win32:
1373 // FIXME: this is invalid for WindowsCE
1375 case llvm::Triple::MacOSX:
1376 case llvm::Triple::IOS:
1377 case llvm::Triple::WatchOS:
1388 StringRef CPU = ARM::getDefaultCPU(MArch);
1392 // If no specific architecture version is requested, return the minimum CPU
1393 // required by the OS and environment.
1395 case llvm::Triple::NetBSD:
1396 switch (getEnvironment()) {
1397 case llvm::Triple::GNUEABIHF:
1398 case llvm::Triple::GNUEABI:
1399 case llvm::Triple::EABIHF:
1400 case llvm::Triple::EABI:
1401 return "arm926ej-s";
1405 case llvm::Triple::NaCl:
1408 switch (getEnvironment()) {
1409 case llvm::Triple::EABIHF:
1410 case llvm::Triple::GNUEABIHF:
1411 return "arm1176jzf-s";
1417 llvm_unreachable("invalid arch name");