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;
500 return Triple::ARMSubArch_v6;
502 case ARM::AK_ARMV6KZ:
503 return Triple::ARMSubArch_v6k;
504 case ARM::AK_ARMV6T2:
505 return Triple::ARMSubArch_v6t2;
507 return Triple::ARMSubArch_v6m;
510 return Triple::ARMSubArch_v7;
512 return Triple::ARMSubArch_v7k;
514 return Triple::ARMSubArch_v7m;
516 return Triple::ARMSubArch_v7s;
517 case ARM::AK_ARMV7EM:
518 return Triple::ARMSubArch_v7em;
520 return Triple::ARMSubArch_v8;
521 case ARM::AK_ARMV8_1A:
522 return Triple::ARMSubArch_v8_1a;
524 return Triple::NoSubArch;
528 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
530 case Triple::UnknownObjectFormat: return "";
531 case Triple::COFF: return "coff";
532 case Triple::ELF: return "elf";
533 case Triple::MachO: return "macho";
535 llvm_unreachable("unknown object format type");
538 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
539 switch (T.getArch()) {
542 case Triple::hexagon:
546 case Triple::mips64el:
550 case Triple::sparcv9:
551 case Triple::systemz:
553 case Triple::ppc64le:
559 return Triple::MachO;
564 // Unknown for now, until an object format is specified.
565 return Triple::UnknownObjectFormat;
569 return Triple::MachO;
570 else if (T.isOSWindows())
575 /// \brief Construct a triple from the string representation provided.
577 /// This stores the string representation and parses the various pieces into
579 Triple::Triple(const Twine &Str)
580 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
581 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
582 ObjectFormat(UnknownObjectFormat) {
583 // Do minimal parsing by hand here.
584 SmallVector<StringRef, 4> Components;
585 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
586 if (Components.size() > 0) {
587 Arch = parseArch(Components[0]);
588 SubArch = parseSubArch(Components[0]);
589 if (Components.size() > 1) {
590 Vendor = parseVendor(Components[1]);
591 if (Components.size() > 2) {
592 OS = parseOS(Components[2]);
593 if (Components.size() > 3) {
594 Environment = parseEnvironment(Components[3]);
595 ObjectFormat = parseFormat(Components[3]);
600 if (ObjectFormat == UnknownObjectFormat)
601 ObjectFormat = getDefaultFormat(*this);
604 /// \brief Construct a triple from string representations of the architecture,
607 /// This joins each argument into a canonical string representation and parses
608 /// them into enum members. It leaves the environment unknown and omits it from
609 /// the string representation.
610 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
611 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
612 Arch(parseArch(ArchStr.str())),
613 SubArch(parseSubArch(ArchStr.str())),
614 Vendor(parseVendor(VendorStr.str())),
615 OS(parseOS(OSStr.str())),
616 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
617 ObjectFormat = getDefaultFormat(*this);
620 /// \brief Construct a triple from string representations of the architecture,
621 /// vendor, OS, and environment.
623 /// This joins each argument into a canonical string representation and parses
624 /// them into enum members.
625 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
626 const Twine &EnvironmentStr)
627 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
628 EnvironmentStr).str()),
629 Arch(parseArch(ArchStr.str())),
630 SubArch(parseSubArch(ArchStr.str())),
631 Vendor(parseVendor(VendorStr.str())),
632 OS(parseOS(OSStr.str())),
633 Environment(parseEnvironment(EnvironmentStr.str())),
634 ObjectFormat(parseFormat(EnvironmentStr.str())) {
635 if (ObjectFormat == Triple::UnknownObjectFormat)
636 ObjectFormat = getDefaultFormat(*this);
639 std::string Triple::normalize(StringRef Str) {
640 bool IsMinGW32 = false;
641 bool IsCygwin = false;
643 // Parse into components.
644 SmallVector<StringRef, 4> Components;
645 Str.split(Components, '-');
647 // If the first component corresponds to a known architecture, preferentially
648 // use it for the architecture. If the second component corresponds to a
649 // known vendor, preferentially use it for the vendor, etc. This avoids silly
650 // component movement when a component parses as (eg) both a valid arch and a
652 ArchType Arch = UnknownArch;
653 if (Components.size() > 0)
654 Arch = parseArch(Components[0]);
655 VendorType Vendor = UnknownVendor;
656 if (Components.size() > 1)
657 Vendor = parseVendor(Components[1]);
658 OSType OS = UnknownOS;
659 if (Components.size() > 2) {
660 OS = parseOS(Components[2]);
661 IsCygwin = Components[2].startswith("cygwin");
662 IsMinGW32 = Components[2].startswith("mingw");
664 EnvironmentType Environment = UnknownEnvironment;
665 if (Components.size() > 3)
666 Environment = parseEnvironment(Components[3]);
667 ObjectFormatType ObjectFormat = UnknownObjectFormat;
668 if (Components.size() > 4)
669 ObjectFormat = parseFormat(Components[4]);
671 // Note which components are already in their final position. These will not
674 Found[0] = Arch != UnknownArch;
675 Found[1] = Vendor != UnknownVendor;
676 Found[2] = OS != UnknownOS;
677 Found[3] = Environment != UnknownEnvironment;
679 // If they are not there already, permute the components into their canonical
680 // positions by seeing if they parse as a valid architecture, and if so moving
681 // the component to the architecture position etc.
682 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
684 continue; // Already in the canonical position.
686 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
687 // Do not reparse any components that already matched.
688 if (Idx < array_lengthof(Found) && Found[Idx])
691 // Does this component parse as valid for the target position?
693 StringRef Comp = Components[Idx];
695 default: llvm_unreachable("unexpected component type!");
697 Arch = parseArch(Comp);
698 Valid = Arch != UnknownArch;
701 Vendor = parseVendor(Comp);
702 Valid = Vendor != UnknownVendor;
706 IsCygwin = Comp.startswith("cygwin");
707 IsMinGW32 = Comp.startswith("mingw");
708 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
711 Environment = parseEnvironment(Comp);
712 Valid = Environment != UnknownEnvironment;
714 ObjectFormat = parseFormat(Comp);
715 Valid = ObjectFormat != UnknownObjectFormat;
720 continue; // Nope, try the next component.
722 // Move the component to the target position, pushing any non-fixed
723 // components that are in the way to the right. This tends to give
724 // good results in the common cases of a forgotten vendor component
725 // or a wrongly positioned environment.
727 // Insert left, pushing the existing components to the right. For
728 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
729 StringRef CurrentComponent(""); // The empty component.
730 // Replace the component we are moving with an empty component.
731 std::swap(CurrentComponent, Components[Idx]);
732 // Insert the component being moved at Pos, displacing any existing
733 // components to the right.
734 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
735 // Skip over any fixed components.
736 while (i < array_lengthof(Found) && Found[i])
738 // Place the component at the new position, getting the component
739 // that was at this position - it will be moved right.
740 std::swap(CurrentComponent, Components[i]);
742 } else if (Pos > Idx) {
743 // Push right by inserting empty components until the component at Idx
744 // reaches the target position Pos. For example, pc-a -> -pc-a when
745 // moving pc to the second position.
747 // Insert one empty component at Idx.
748 StringRef CurrentComponent(""); // The empty component.
749 for (unsigned i = Idx; i < Components.size();) {
750 // Place the component at the new position, getting the component
751 // that was at this position - it will be moved right.
752 std::swap(CurrentComponent, Components[i]);
753 // If it was placed on top of an empty component then we are done.
754 if (CurrentComponent.empty())
756 // Advance to the next component, skipping any fixed components.
757 while (++i < array_lengthof(Found) && Found[i])
760 // The last component was pushed off the end - append it.
761 if (!CurrentComponent.empty())
762 Components.push_back(CurrentComponent);
764 // Advance Idx to the component's new position.
765 while (++Idx < array_lengthof(Found) && Found[Idx])
767 } while (Idx < Pos); // Add more until the final position is reached.
769 assert(Pos < Components.size() && Components[Pos] == Comp &&
770 "Component moved wrong!");
776 // Special case logic goes here. At this point Arch, Vendor and OS have the
777 // correct values for the computed components.
778 std::string NormalizedEnvironment;
779 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
780 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
781 if (AndroidVersion.empty()) {
782 Components[3] = "android";
784 NormalizedEnvironment = Twine("android", AndroidVersion).str();
785 Components[3] = NormalizedEnvironment;
789 if (OS == Triple::Win32) {
790 Components.resize(4);
791 Components[2] = "windows";
792 if (Environment == UnknownEnvironment) {
793 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
794 Components[3] = "msvc";
796 Components[3] = getObjectFormatTypeName(ObjectFormat);
798 } else if (IsMinGW32) {
799 Components.resize(4);
800 Components[2] = "windows";
801 Components[3] = "gnu";
802 } else if (IsCygwin) {
803 Components.resize(4);
804 Components[2] = "windows";
805 Components[3] = "cygnus";
807 if (IsMinGW32 || IsCygwin ||
808 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
809 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
810 Components.resize(5);
811 Components[4] = getObjectFormatTypeName(ObjectFormat);
815 // Stick the corrected components back together to form the normalized string.
816 std::string Normalized;
817 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
818 if (i) Normalized += '-';
819 Normalized += Components[i];
824 StringRef Triple::getArchName() const {
825 return StringRef(Data).split('-').first; // Isolate first component
828 StringRef Triple::getVendorName() const {
829 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
830 return Tmp.split('-').first; // Isolate second component
833 StringRef Triple::getOSName() const {
834 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
835 Tmp = Tmp.split('-').second; // Strip second component
836 return Tmp.split('-').first; // Isolate third component
839 StringRef Triple::getEnvironmentName() const {
840 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
841 Tmp = Tmp.split('-').second; // Strip second component
842 return Tmp.split('-').second; // Strip third component
845 StringRef Triple::getOSAndEnvironmentName() const {
846 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
847 return Tmp.split('-').second; // Strip second component
850 static unsigned EatNumber(StringRef &Str) {
851 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
855 // Consume the leading digit.
856 Result = Result*10 + (Str[0] - '0');
860 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
865 static void parseVersionFromName(StringRef Name, unsigned &Major,
866 unsigned &Minor, unsigned &Micro) {
867 // Any unset version defaults to 0.
868 Major = Minor = Micro = 0;
870 // Parse up to three components.
871 unsigned *Components[3] = {&Major, &Minor, &Micro};
872 for (unsigned i = 0; i != 3; ++i) {
873 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
876 // Consume the leading number.
877 *Components[i] = EatNumber(Name);
879 // Consume the separator, if present.
880 if (Name.startswith("."))
881 Name = Name.substr(1);
885 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
886 unsigned &Micro) const {
887 StringRef EnvironmentName = getEnvironmentName();
888 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
889 if (EnvironmentName.startswith(EnvironmentTypeName))
890 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
892 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
895 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
896 unsigned &Micro) const {
897 StringRef OSName = getOSName();
898 // Assume that the OS portion of the triple starts with the canonical name.
899 StringRef OSTypeName = getOSTypeName(getOS());
900 if (OSName.startswith(OSTypeName))
901 OSName = OSName.substr(OSTypeName.size());
903 parseVersionFromName(OSName, Major, Minor, Micro);
906 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
907 unsigned &Micro) const {
908 getOSVersion(Major, Minor, Micro);
911 default: llvm_unreachable("unexpected OS for Darwin triple");
913 // Default to darwin8, i.e., MacOSX 10.4.
916 // Darwin version numbers are skewed from OS X versions.
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
963 getOSVersion(Major, Minor, Micro);
964 // Default to 5.0 (or 7.0 for arm64).
966 Major = (getArch() == aarch64) ? 7 : 5;
969 llvm_unreachable("conflicting triple info");
973 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
974 unsigned &Micro) const {
976 default: llvm_unreachable("unexpected OS for Darwin triple");
979 // Ignore the version from the triple. This is only handled because the
980 // the clang driver combines OS X and IOS support into a common Darwin
981 // toolchain that wants to know the iOS version number even when targeting
988 getOSVersion(Major, Minor, Micro);
993 llvm_unreachable("conflicting triple info");
997 void Triple::setTriple(const Twine &Str) {
1001 void Triple::setArch(ArchType Kind) {
1002 setArchName(getArchTypeName(Kind));
1005 void Triple::setVendor(VendorType Kind) {
1006 setVendorName(getVendorTypeName(Kind));
1009 void Triple::setOS(OSType Kind) {
1010 setOSName(getOSTypeName(Kind));
1013 void Triple::setEnvironment(EnvironmentType Kind) {
1014 if (ObjectFormat == getDefaultFormat(*this))
1015 return setEnvironmentName(getEnvironmentTypeName(Kind));
1017 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1018 getObjectFormatTypeName(ObjectFormat)).str());
1021 void Triple::setObjectFormat(ObjectFormatType Kind) {
1022 if (Environment == UnknownEnvironment)
1023 return setEnvironmentName(getObjectFormatTypeName(Kind));
1025 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1026 getObjectFormatTypeName(Kind)).str());
1029 void Triple::setArchName(StringRef Str) {
1030 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1031 SmallString<64> Triple;
1034 Triple += getVendorName();
1036 Triple += getOSAndEnvironmentName();
1040 void Triple::setVendorName(StringRef Str) {
1041 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1044 void Triple::setOSName(StringRef Str) {
1045 if (hasEnvironment())
1046 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1047 "-" + getEnvironmentName());
1049 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1052 void Triple::setEnvironmentName(StringRef Str) {
1053 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1057 void Triple::setOSAndEnvironmentName(StringRef Str) {
1058 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1061 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1063 case llvm::Triple::UnknownArch:
1066 case llvm::Triple::avr:
1067 case llvm::Triple::msp430:
1070 case llvm::Triple::arm:
1071 case llvm::Triple::armeb:
1072 case llvm::Triple::hexagon:
1073 case llvm::Triple::le32:
1074 case llvm::Triple::mips:
1075 case llvm::Triple::mipsel:
1076 case llvm::Triple::nvptx:
1077 case llvm::Triple::ppc:
1078 case llvm::Triple::r600:
1079 case llvm::Triple::sparc:
1080 case llvm::Triple::sparcel:
1081 case llvm::Triple::tce:
1082 case llvm::Triple::thumb:
1083 case llvm::Triple::thumbeb:
1084 case llvm::Triple::x86:
1085 case llvm::Triple::xcore:
1086 case llvm::Triple::amdil:
1087 case llvm::Triple::hsail:
1088 case llvm::Triple::spir:
1089 case llvm::Triple::kalimba:
1090 case llvm::Triple::shave:
1091 case llvm::Triple::wasm32:
1094 case llvm::Triple::aarch64:
1095 case llvm::Triple::aarch64_be:
1096 case llvm::Triple::amdgcn:
1097 case llvm::Triple::bpfel:
1098 case llvm::Triple::bpfeb:
1099 case llvm::Triple::le64:
1100 case llvm::Triple::mips64:
1101 case llvm::Triple::mips64el:
1102 case llvm::Triple::nvptx64:
1103 case llvm::Triple::ppc64:
1104 case llvm::Triple::ppc64le:
1105 case llvm::Triple::sparcv9:
1106 case llvm::Triple::systemz:
1107 case llvm::Triple::x86_64:
1108 case llvm::Triple::amdil64:
1109 case llvm::Triple::hsail64:
1110 case llvm::Triple::spir64:
1111 case llvm::Triple::wasm64:
1114 llvm_unreachable("Invalid architecture value");
1117 bool Triple::isArch64Bit() const {
1118 return getArchPointerBitWidth(getArch()) == 64;
1121 bool Triple::isArch32Bit() const {
1122 return getArchPointerBitWidth(getArch()) == 32;
1125 bool Triple::isArch16Bit() const {
1126 return getArchPointerBitWidth(getArch()) == 16;
1129 Triple Triple::get32BitArchVariant() const {
1131 switch (getArch()) {
1132 case Triple::UnknownArch:
1133 case Triple::aarch64:
1134 case Triple::aarch64_be:
1135 case Triple::amdgcn:
1139 case Triple::msp430:
1140 case Triple::systemz:
1141 case Triple::ppc64le:
1142 T.setArch(UnknownArch);
1150 case Triple::hexagon:
1151 case Triple::kalimba:
1154 case Triple::mipsel:
1159 case Triple::sparcel:
1162 case Triple::thumbeb:
1166 case Triple::wasm32:
1170 case Triple::le64: T.setArch(Triple::le32); break;
1171 case Triple::mips64: T.setArch(Triple::mips); break;
1172 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1173 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1174 case Triple::ppc64: T.setArch(Triple::ppc); break;
1175 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1176 case Triple::x86_64: T.setArch(Triple::x86); break;
1177 case Triple::amdil64: T.setArch(Triple::amdil); break;
1178 case Triple::hsail64: T.setArch(Triple::hsail); break;
1179 case Triple::spir64: T.setArch(Triple::spir); break;
1180 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1185 Triple Triple::get64BitArchVariant() const {
1187 switch (getArch()) {
1188 case Triple::UnknownArch:
1192 case Triple::hexagon:
1193 case Triple::kalimba:
1194 case Triple::msp430:
1198 case Triple::thumbeb:
1200 case Triple::sparcel:
1202 T.setArch(UnknownArch);
1205 case Triple::aarch64:
1206 case Triple::aarch64_be:
1210 case Triple::amdil64:
1211 case Triple::amdgcn:
1212 case Triple::hsail64:
1213 case Triple::spir64:
1214 case Triple::mips64:
1215 case Triple::mips64el:
1216 case Triple::nvptx64:
1218 case Triple::ppc64le:
1219 case Triple::sparcv9:
1220 case Triple::systemz:
1221 case Triple::x86_64:
1222 case Triple::wasm64:
1226 case Triple::le32: T.setArch(Triple::le64); break;
1227 case Triple::mips: T.setArch(Triple::mips64); break;
1228 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1229 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1230 case Triple::ppc: T.setArch(Triple::ppc64); break;
1231 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1232 case Triple::x86: T.setArch(Triple::x86_64); break;
1233 case Triple::amdil: T.setArch(Triple::amdil64); break;
1234 case Triple::hsail: T.setArch(Triple::hsail64); break;
1235 case Triple::spir: T.setArch(Triple::spir64); break;
1236 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1241 Triple Triple::getBigEndianArchVariant() const {
1243 switch (getArch()) {
1244 case Triple::UnknownArch:
1245 case Triple::amdgcn:
1246 case Triple::amdil64:
1249 case Triple::hexagon:
1250 case Triple::hsail64:
1252 case Triple::kalimba:
1255 case Triple::msp430:
1256 case Triple::nvptx64:
1260 case Triple::spir64:
1262 case Triple::wasm32:
1263 case Triple::wasm64:
1265 case Triple::x86_64:
1268 // ARM is intentionally unsupported here, changing the architecture would
1269 // drop any arch suffixes.
1272 T.setArch(UnknownArch);
1275 case Triple::aarch64_be:
1278 case Triple::mips64:
1283 case Triple::sparcv9:
1284 case Triple::systemz:
1286 case Triple::thumbeb:
1287 // Already big endian.
1290 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1291 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1292 case Triple::mips64el:T.setArch(Triple::mips64); break;
1293 case Triple::mipsel: T.setArch(Triple::mips); break;
1294 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1295 case Triple::sparcel: T.setArch(Triple::sparc); break;
1300 Triple Triple::getLittleEndianArchVariant() const {
1302 switch (getArch()) {
1303 case Triple::UnknownArch:
1305 case Triple::sparcv9:
1306 case Triple::systemz:
1309 // ARM is intentionally unsupported here, changing the architecture would
1310 // drop any arch suffixes.
1312 case Triple::thumbeb:
1313 T.setArch(UnknownArch);
1316 case Triple::aarch64:
1317 case Triple::amdgcn:
1318 case Triple::amdil64:
1323 case Triple::hexagon:
1324 case Triple::hsail64:
1326 case Triple::kalimba:
1329 case Triple::mips64el:
1330 case Triple::mipsel:
1331 case Triple::msp430:
1332 case Triple::nvptx64:
1334 case Triple::ppc64le:
1337 case Triple::sparcel:
1338 case Triple::spir64:
1341 case Triple::wasm32:
1342 case Triple::wasm64:
1344 case Triple::x86_64:
1346 // Already little endian.
1349 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1350 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1351 case Triple::mips64: T.setArch(Triple::mips64el); break;
1352 case Triple::mips: T.setArch(Triple::mipsel); break;
1353 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1354 case Triple::sparc: T.setArch(Triple::sparcel); break;
1359 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1361 MArch = getArchName();
1362 MArch = ARM::getCanonicalArchName(MArch);
1364 // Some defaults are forced.
1366 case llvm::Triple::FreeBSD:
1367 case llvm::Triple::NetBSD:
1368 if (!MArch.empty() && MArch == "v6")
1369 return "arm1176jzf-s";
1371 case llvm::Triple::Win32:
1372 // FIXME: this is invalid for WindowsCE
1381 StringRef CPU = ARM::getDefaultCPU(MArch);
1385 // If no specific architecture version is requested, return the minimum CPU
1386 // required by the OS and environment.
1388 case llvm::Triple::NetBSD:
1389 switch (getEnvironment()) {
1390 case llvm::Triple::GNUEABIHF:
1391 case llvm::Triple::GNUEABI:
1392 case llvm::Triple::EABIHF:
1393 case llvm::Triple::EABI:
1394 return "arm926ej-s";
1398 case llvm::Triple::NaCl:
1401 switch (getEnvironment()) {
1402 case llvm::Triple::EABIHF:
1403 case llvm::Triple::GNUEABIHF:
1404 return "arm1176jzf-s";
1410 llvm_unreachable("invalid arch name");