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:
556 case Triple::ppc64le:
562 return Triple::MachO;
567 return Triple::MachO;
568 else if (T.isOSWindows())
573 /// \brief Construct a triple from the string representation provided.
575 /// This stores the string representation and parses the various pieces into
577 Triple::Triple(const Twine &Str)
578 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
579 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
580 ObjectFormat(UnknownObjectFormat) {
581 // Do minimal parsing by hand here.
582 SmallVector<StringRef, 4> Components;
583 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
584 if (Components.size() > 0) {
585 Arch = parseArch(Components[0]);
586 SubArch = parseSubArch(Components[0]);
587 if (Components.size() > 1) {
588 Vendor = parseVendor(Components[1]);
589 if (Components.size() > 2) {
590 OS = parseOS(Components[2]);
591 if (Components.size() > 3) {
592 Environment = parseEnvironment(Components[3]);
593 ObjectFormat = parseFormat(Components[3]);
598 if (ObjectFormat == UnknownObjectFormat)
599 ObjectFormat = getDefaultFormat(*this);
602 /// \brief Construct a triple from string representations of the architecture,
605 /// This joins each argument into a canonical string representation and parses
606 /// them into enum members. It leaves the environment unknown and omits it from
607 /// the string representation.
608 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
609 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
610 Arch(parseArch(ArchStr.str())),
611 SubArch(parseSubArch(ArchStr.str())),
612 Vendor(parseVendor(VendorStr.str())),
613 OS(parseOS(OSStr.str())),
614 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
615 ObjectFormat = getDefaultFormat(*this);
618 /// \brief Construct a triple from string representations of the architecture,
619 /// vendor, OS, and environment.
621 /// This joins each argument into a canonical string representation and parses
622 /// them into enum members.
623 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
624 const Twine &EnvironmentStr)
625 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
626 EnvironmentStr).str()),
627 Arch(parseArch(ArchStr.str())),
628 SubArch(parseSubArch(ArchStr.str())),
629 Vendor(parseVendor(VendorStr.str())),
630 OS(parseOS(OSStr.str())),
631 Environment(parseEnvironment(EnvironmentStr.str())),
632 ObjectFormat(parseFormat(EnvironmentStr.str())) {
633 if (ObjectFormat == Triple::UnknownObjectFormat)
634 ObjectFormat = getDefaultFormat(*this);
637 std::string Triple::normalize(StringRef Str) {
638 bool IsMinGW32 = false;
639 bool IsCygwin = false;
641 // Parse into components.
642 SmallVector<StringRef, 4> Components;
643 Str.split(Components, '-');
645 // If the first component corresponds to a known architecture, preferentially
646 // use it for the architecture. If the second component corresponds to a
647 // known vendor, preferentially use it for the vendor, etc. This avoids silly
648 // component movement when a component parses as (eg) both a valid arch and a
650 ArchType Arch = UnknownArch;
651 if (Components.size() > 0)
652 Arch = parseArch(Components[0]);
653 VendorType Vendor = UnknownVendor;
654 if (Components.size() > 1)
655 Vendor = parseVendor(Components[1]);
656 OSType OS = UnknownOS;
657 if (Components.size() > 2) {
658 OS = parseOS(Components[2]);
659 IsCygwin = Components[2].startswith("cygwin");
660 IsMinGW32 = Components[2].startswith("mingw");
662 EnvironmentType Environment = UnknownEnvironment;
663 if (Components.size() > 3)
664 Environment = parseEnvironment(Components[3]);
665 ObjectFormatType ObjectFormat = UnknownObjectFormat;
666 if (Components.size() > 4)
667 ObjectFormat = parseFormat(Components[4]);
669 // Note which components are already in their final position. These will not
672 Found[0] = Arch != UnknownArch;
673 Found[1] = Vendor != UnknownVendor;
674 Found[2] = OS != UnknownOS;
675 Found[3] = Environment != UnknownEnvironment;
677 // If they are not there already, permute the components into their canonical
678 // positions by seeing if they parse as a valid architecture, and if so moving
679 // the component to the architecture position etc.
680 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
682 continue; // Already in the canonical position.
684 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
685 // Do not reparse any components that already matched.
686 if (Idx < array_lengthof(Found) && Found[Idx])
689 // Does this component parse as valid for the target position?
691 StringRef Comp = Components[Idx];
693 default: llvm_unreachable("unexpected component type!");
695 Arch = parseArch(Comp);
696 Valid = Arch != UnknownArch;
699 Vendor = parseVendor(Comp);
700 Valid = Vendor != UnknownVendor;
704 IsCygwin = Comp.startswith("cygwin");
705 IsMinGW32 = Comp.startswith("mingw");
706 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
709 Environment = parseEnvironment(Comp);
710 Valid = Environment != UnknownEnvironment;
712 ObjectFormat = parseFormat(Comp);
713 Valid = ObjectFormat != UnknownObjectFormat;
718 continue; // Nope, try the next component.
720 // Move the component to the target position, pushing any non-fixed
721 // components that are in the way to the right. This tends to give
722 // good results in the common cases of a forgotten vendor component
723 // or a wrongly positioned environment.
725 // Insert left, pushing the existing components to the right. For
726 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
727 StringRef CurrentComponent(""); // The empty component.
728 // Replace the component we are moving with an empty component.
729 std::swap(CurrentComponent, Components[Idx]);
730 // Insert the component being moved at Pos, displacing any existing
731 // components to the right.
732 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
733 // Skip over any fixed components.
734 while (i < array_lengthof(Found) && Found[i])
736 // Place the component at the new position, getting the component
737 // that was at this position - it will be moved right.
738 std::swap(CurrentComponent, Components[i]);
740 } else if (Pos > Idx) {
741 // Push right by inserting empty components until the component at Idx
742 // reaches the target position Pos. For example, pc-a -> -pc-a when
743 // moving pc to the second position.
745 // Insert one empty component at Idx.
746 StringRef CurrentComponent(""); // The empty component.
747 for (unsigned i = Idx; i < Components.size();) {
748 // Place the component at the new position, getting the component
749 // that was at this position - it will be moved right.
750 std::swap(CurrentComponent, Components[i]);
751 // If it was placed on top of an empty component then we are done.
752 if (CurrentComponent.empty())
754 // Advance to the next component, skipping any fixed components.
755 while (++i < array_lengthof(Found) && Found[i])
758 // The last component was pushed off the end - append it.
759 if (!CurrentComponent.empty())
760 Components.push_back(CurrentComponent);
762 // Advance Idx to the component's new position.
763 while (++Idx < array_lengthof(Found) && Found[Idx])
765 } while (Idx < Pos); // Add more until the final position is reached.
767 assert(Pos < Components.size() && Components[Pos] == Comp &&
768 "Component moved wrong!");
774 // Special case logic goes here. At this point Arch, Vendor and OS have the
775 // correct values for the computed components.
776 std::string NormalizedEnvironment;
777 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
778 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
779 if (AndroidVersion.empty()) {
780 Components[3] = "android";
782 NormalizedEnvironment = Twine("android", AndroidVersion).str();
783 Components[3] = NormalizedEnvironment;
787 if (OS == Triple::Win32) {
788 Components.resize(4);
789 Components[2] = "windows";
790 if (Environment == UnknownEnvironment) {
791 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
792 Components[3] = "msvc";
794 Components[3] = getObjectFormatTypeName(ObjectFormat);
796 } else if (IsMinGW32) {
797 Components.resize(4);
798 Components[2] = "windows";
799 Components[3] = "gnu";
800 } else if (IsCygwin) {
801 Components.resize(4);
802 Components[2] = "windows";
803 Components[3] = "cygnus";
805 if (IsMinGW32 || IsCygwin ||
806 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
807 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
808 Components.resize(5);
809 Components[4] = getObjectFormatTypeName(ObjectFormat);
813 // Stick the corrected components back together to form the normalized string.
814 std::string Normalized;
815 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
816 if (i) Normalized += '-';
817 Normalized += Components[i];
822 StringRef Triple::getArchName() const {
823 return StringRef(Data).split('-').first; // Isolate first component
826 StringRef Triple::getVendorName() const {
827 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
828 return Tmp.split('-').first; // Isolate second component
831 StringRef Triple::getOSName() const {
832 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
833 Tmp = Tmp.split('-').second; // Strip second component
834 return Tmp.split('-').first; // Isolate third component
837 StringRef Triple::getEnvironmentName() const {
838 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
839 Tmp = Tmp.split('-').second; // Strip second component
840 return Tmp.split('-').second; // Strip third component
843 StringRef Triple::getOSAndEnvironmentName() const {
844 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
845 return Tmp.split('-').second; // Strip second component
848 static unsigned EatNumber(StringRef &Str) {
849 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
853 // Consume the leading digit.
854 Result = Result*10 + (Str[0] - '0');
858 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
863 static void parseVersionFromName(StringRef Name, unsigned &Major,
864 unsigned &Minor, unsigned &Micro) {
865 // Any unset version defaults to 0.
866 Major = Minor = Micro = 0;
868 // Parse up to three components.
869 unsigned *Components[3] = {&Major, &Minor, &Micro};
870 for (unsigned i = 0; i != 3; ++i) {
871 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
874 // Consume the leading number.
875 *Components[i] = EatNumber(Name);
877 // Consume the separator, if present.
878 if (Name.startswith("."))
879 Name = Name.substr(1);
883 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
884 unsigned &Micro) const {
885 StringRef EnvironmentName = getEnvironmentName();
886 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
887 if (EnvironmentName.startswith(EnvironmentTypeName))
888 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
890 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
893 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
894 unsigned &Micro) const {
895 StringRef OSName = getOSName();
896 // Assume that the OS portion of the triple starts with the canonical name.
897 StringRef OSTypeName = getOSTypeName(getOS());
898 if (OSName.startswith(OSTypeName))
899 OSName = OSName.substr(OSTypeName.size());
901 parseVersionFromName(OSName, Major, Minor, Micro);
904 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
905 unsigned &Micro) const {
906 getOSVersion(Major, Minor, Micro);
909 default: llvm_unreachable("unexpected OS for Darwin triple");
911 // Default to darwin8, i.e., MacOSX 10.4.
914 // Darwin version numbers are skewed from OS X versions.
933 // Ignore the version from the triple. This is only handled because the
934 // the clang driver combines OS X and IOS support into a common Darwin
935 // toolchain that wants to know the OS X version number even when targeting
945 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
946 unsigned &Micro) const {
948 default: llvm_unreachable("unexpected OS for Darwin triple");
951 // Ignore the version from the triple. This is only handled because the
952 // the clang driver combines OS X and IOS support into a common Darwin
953 // toolchain that wants to know the iOS version number even when targeting
961 getOSVersion(Major, Minor, Micro);
962 // Default to 5.0 (or 7.0 for arm64).
964 Major = (getArch() == aarch64) ? 7 : 5;
967 llvm_unreachable("conflicting triple info");
971 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
972 unsigned &Micro) const {
974 default: llvm_unreachable("unexpected OS for Darwin triple");
977 // Ignore the version from the triple. This is only handled because the
978 // the clang driver combines OS X and IOS support into a common Darwin
979 // toolchain that wants to know the iOS version number even when targeting
986 getOSVersion(Major, Minor, Micro);
991 llvm_unreachable("conflicting triple info");
995 void Triple::setTriple(const Twine &Str) {
999 void Triple::setArch(ArchType Kind) {
1000 setArchName(getArchTypeName(Kind));
1003 void Triple::setVendor(VendorType Kind) {
1004 setVendorName(getVendorTypeName(Kind));
1007 void Triple::setOS(OSType Kind) {
1008 setOSName(getOSTypeName(Kind));
1011 void Triple::setEnvironment(EnvironmentType Kind) {
1012 if (ObjectFormat == getDefaultFormat(*this))
1013 return setEnvironmentName(getEnvironmentTypeName(Kind));
1015 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1016 getObjectFormatTypeName(ObjectFormat)).str());
1019 void Triple::setObjectFormat(ObjectFormatType Kind) {
1020 if (Environment == UnknownEnvironment)
1021 return setEnvironmentName(getObjectFormatTypeName(Kind));
1023 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1024 getObjectFormatTypeName(Kind)).str());
1027 void Triple::setArchName(StringRef Str) {
1028 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1029 SmallString<64> Triple;
1032 Triple += getVendorName();
1034 Triple += getOSAndEnvironmentName();
1038 void Triple::setVendorName(StringRef Str) {
1039 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1042 void Triple::setOSName(StringRef Str) {
1043 if (hasEnvironment())
1044 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1045 "-" + getEnvironmentName());
1047 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1050 void Triple::setEnvironmentName(StringRef Str) {
1051 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1055 void Triple::setOSAndEnvironmentName(StringRef Str) {
1056 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1059 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1061 case llvm::Triple::UnknownArch:
1064 case llvm::Triple::avr:
1065 case llvm::Triple::msp430:
1068 case llvm::Triple::arm:
1069 case llvm::Triple::armeb:
1070 case llvm::Triple::hexagon:
1071 case llvm::Triple::le32:
1072 case llvm::Triple::mips:
1073 case llvm::Triple::mipsel:
1074 case llvm::Triple::nvptx:
1075 case llvm::Triple::ppc:
1076 case llvm::Triple::r600:
1077 case llvm::Triple::sparc:
1078 case llvm::Triple::sparcel:
1079 case llvm::Triple::tce:
1080 case llvm::Triple::thumb:
1081 case llvm::Triple::thumbeb:
1082 case llvm::Triple::x86:
1083 case llvm::Triple::xcore:
1084 case llvm::Triple::amdil:
1085 case llvm::Triple::hsail:
1086 case llvm::Triple::spir:
1087 case llvm::Triple::kalimba:
1088 case llvm::Triple::shave:
1089 case llvm::Triple::wasm32:
1092 case llvm::Triple::aarch64:
1093 case llvm::Triple::aarch64_be:
1094 case llvm::Triple::amdgcn:
1095 case llvm::Triple::bpfel:
1096 case llvm::Triple::bpfeb:
1097 case llvm::Triple::le64:
1098 case llvm::Triple::mips64:
1099 case llvm::Triple::mips64el:
1100 case llvm::Triple::nvptx64:
1101 case llvm::Triple::ppc64:
1102 case llvm::Triple::ppc64le:
1103 case llvm::Triple::sparcv9:
1104 case llvm::Triple::systemz:
1105 case llvm::Triple::x86_64:
1106 case llvm::Triple::amdil64:
1107 case llvm::Triple::hsail64:
1108 case llvm::Triple::spir64:
1109 case llvm::Triple::wasm64:
1112 llvm_unreachable("Invalid architecture value");
1115 bool Triple::isArch64Bit() const {
1116 return getArchPointerBitWidth(getArch()) == 64;
1119 bool Triple::isArch32Bit() const {
1120 return getArchPointerBitWidth(getArch()) == 32;
1123 bool Triple::isArch16Bit() const {
1124 return getArchPointerBitWidth(getArch()) == 16;
1127 Triple Triple::get32BitArchVariant() const {
1129 switch (getArch()) {
1130 case Triple::UnknownArch:
1131 case Triple::aarch64:
1132 case Triple::aarch64_be:
1133 case Triple::amdgcn:
1137 case Triple::msp430:
1138 case Triple::systemz:
1139 case Triple::ppc64le:
1140 T.setArch(UnknownArch);
1148 case Triple::hexagon:
1149 case Triple::kalimba:
1152 case Triple::mipsel:
1157 case Triple::sparcel:
1160 case Triple::thumbeb:
1164 case Triple::wasm32:
1168 case Triple::le64: T.setArch(Triple::le32); break;
1169 case Triple::mips64: T.setArch(Triple::mips); break;
1170 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1171 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1172 case Triple::ppc64: T.setArch(Triple::ppc); break;
1173 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1174 case Triple::x86_64: T.setArch(Triple::x86); break;
1175 case Triple::amdil64: T.setArch(Triple::amdil); break;
1176 case Triple::hsail64: T.setArch(Triple::hsail); break;
1177 case Triple::spir64: T.setArch(Triple::spir); break;
1178 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1183 Triple Triple::get64BitArchVariant() const {
1185 switch (getArch()) {
1186 case Triple::UnknownArch:
1190 case Triple::hexagon:
1191 case Triple::kalimba:
1192 case Triple::msp430:
1196 case Triple::thumbeb:
1198 case Triple::sparcel:
1200 T.setArch(UnknownArch);
1203 case Triple::aarch64:
1204 case Triple::aarch64_be:
1208 case Triple::amdil64:
1209 case Triple::amdgcn:
1210 case Triple::hsail64:
1211 case Triple::spir64:
1212 case Triple::mips64:
1213 case Triple::mips64el:
1214 case Triple::nvptx64:
1216 case Triple::ppc64le:
1217 case Triple::sparcv9:
1218 case Triple::systemz:
1219 case Triple::x86_64:
1220 case Triple::wasm64:
1224 case Triple::le32: T.setArch(Triple::le64); break;
1225 case Triple::mips: T.setArch(Triple::mips64); break;
1226 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1227 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1228 case Triple::ppc: T.setArch(Triple::ppc64); break;
1229 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1230 case Triple::x86: T.setArch(Triple::x86_64); break;
1231 case Triple::amdil: T.setArch(Triple::amdil64); break;
1232 case Triple::hsail: T.setArch(Triple::hsail64); break;
1233 case Triple::spir: T.setArch(Triple::spir64); break;
1234 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1239 Triple Triple::getBigEndianArchVariant() const {
1241 switch (getArch()) {
1242 case Triple::UnknownArch:
1243 case Triple::amdgcn:
1244 case Triple::amdil64:
1247 case Triple::hexagon:
1248 case Triple::hsail64:
1250 case Triple::kalimba:
1253 case Triple::msp430:
1254 case Triple::nvptx64:
1258 case Triple::spir64:
1260 case Triple::wasm32:
1261 case Triple::wasm64:
1263 case Triple::x86_64:
1266 // ARM is intentionally unsupported here, changing the architecture would
1267 // drop any arch suffixes.
1270 T.setArch(UnknownArch);
1273 case Triple::aarch64_be:
1276 case Triple::mips64:
1281 case Triple::sparcv9:
1282 case Triple::systemz:
1284 case Triple::thumbeb:
1285 // Already big endian.
1288 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1289 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1290 case Triple::mips64el:T.setArch(Triple::mips64); break;
1291 case Triple::mipsel: T.setArch(Triple::mips); break;
1292 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1293 case Triple::sparcel: T.setArch(Triple::sparc); break;
1298 Triple Triple::getLittleEndianArchVariant() const {
1300 switch (getArch()) {
1301 case Triple::UnknownArch:
1303 case Triple::sparcv9:
1304 case Triple::systemz:
1307 // ARM is intentionally unsupported here, changing the architecture would
1308 // drop any arch suffixes.
1310 case Triple::thumbeb:
1311 T.setArch(UnknownArch);
1314 case Triple::aarch64:
1315 case Triple::amdgcn:
1316 case Triple::amdil64:
1321 case Triple::hexagon:
1322 case Triple::hsail64:
1324 case Triple::kalimba:
1327 case Triple::mips64el:
1328 case Triple::mipsel:
1329 case Triple::msp430:
1330 case Triple::nvptx64:
1332 case Triple::ppc64le:
1335 case Triple::sparcel:
1336 case Triple::spir64:
1339 case Triple::wasm32:
1340 case Triple::wasm64:
1342 case Triple::x86_64:
1344 // Already little endian.
1347 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1348 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1349 case Triple::mips64: T.setArch(Triple::mips64el); break;
1350 case Triple::mips: T.setArch(Triple::mipsel); break;
1351 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1352 case Triple::sparc: T.setArch(Triple::sparcel); break;
1357 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1359 MArch = getArchName();
1360 MArch = ARM::getCanonicalArchName(MArch);
1362 // Some defaults are forced.
1364 case llvm::Triple::FreeBSD:
1365 case llvm::Triple::NetBSD:
1366 if (!MArch.empty() && MArch == "v6")
1367 return "arm1176jzf-s";
1369 case llvm::Triple::Win32:
1370 // FIXME: this is invalid for WindowsCE
1372 case llvm::Triple::MacOSX:
1373 case llvm::Triple::IOS:
1374 case llvm::Triple::WatchOS:
1385 StringRef CPU = ARM::getDefaultCPU(MArch);
1389 // If no specific architecture version is requested, return the minimum CPU
1390 // required by the OS and environment.
1392 case llvm::Triple::NetBSD:
1393 switch (getEnvironment()) {
1394 case llvm::Triple::GNUEABIHF:
1395 case llvm::Triple::GNUEABI:
1396 case llvm::Triple::EABIHF:
1397 case llvm::Triple::EABI:
1398 return "arm926ej-s";
1402 case llvm::Triple::NaCl:
1405 switch (getEnvironment()) {
1406 case llvm::Triple::EABIHF:
1407 case llvm::Triple::GNUEABIHF:
1408 return "arm1176jzf-s";
1414 llvm_unreachable("invalid arch name");