1 //===--- Triple.cpp - Target triple helper class --------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/Triple.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringSwitch.h"
14 #include "llvm/Support/ErrorHandling.h"
15 #include "llvm/Support/TargetParser.h"
16 #include "llvm/Support/Host.h"
20 const char *Triple::getArchTypeName(ArchType Kind) {
22 case UnknownArch: return "unknown";
24 case aarch64: return "aarch64";
25 case aarch64_be: return "aarch64_be";
26 case arm: return "arm";
27 case armeb: return "armeb";
28 case bpfel: return "bpfel";
29 case bpfeb: return "bpfeb";
30 case hexagon: return "hexagon";
31 case mips: return "mips";
32 case mipsel: return "mipsel";
33 case mips64: return "mips64";
34 case mips64el: return "mips64el";
35 case msp430: return "msp430";
36 case ppc64: return "powerpc64";
37 case ppc64le: return "powerpc64le";
38 case ppc: return "powerpc";
39 case r600: return "r600";
40 case amdgcn: return "amdgcn";
41 case sparc: return "sparc";
42 case sparcv9: return "sparcv9";
43 case sparcel: return "sparcel";
44 case systemz: return "s390x";
45 case tce: return "tce";
46 case thumb: return "thumb";
47 case thumbeb: return "thumbeb";
48 case x86: return "i386";
49 case x86_64: return "x86_64";
50 case xcore: return "xcore";
51 case nvptx: return "nvptx";
52 case nvptx64: return "nvptx64";
53 case le32: return "le32";
54 case le64: return "le64";
55 case amdil: return "amdil";
56 case amdil64: return "amdil64";
57 case hsail: return "hsail";
58 case hsail64: return "hsail64";
59 case spir: return "spir";
60 case spir64: return "spir64";
61 case kalimba: return "kalimba";
62 case shave: return "shave";
63 case wasm32: return "wasm32";
64 case wasm64: return "wasm64";
67 llvm_unreachable("Invalid ArchType!");
70 const char *Triple::getArchTypePrefix(ArchType Kind) {
76 case aarch64_be: return "aarch64";
81 case thumbeb: return "arm";
85 case ppc: return "ppc";
90 case mips64el: return "mips";
92 case hexagon: return "hexagon";
95 case r600: return "amdgpu";
98 case bpfeb: return "bpf";
102 case sparc: return "sparc";
104 case systemz: return "s390";
107 case x86_64: return "x86";
109 case xcore: return "xcore";
111 case nvptx: return "nvptx";
112 case nvptx64: return "nvptx";
114 case le32: return "le32";
115 case le64: return "le64";
118 case amdil64: return "amdil";
121 case hsail64: return "hsail";
124 case spir64: return "spir";
125 case kalimba: return "kalimba";
126 case shave: return "shave";
128 case wasm64: return "wasm";
132 const char *Triple::getVendorTypeName(VendorType Kind) {
134 case UnknownVendor: return "unknown";
136 case Apple: return "apple";
137 case PC: return "pc";
138 case SCEI: return "scei";
139 case BGP: return "bgp";
140 case BGQ: return "bgq";
141 case Freescale: return "fsl";
142 case IBM: return "ibm";
143 case ImaginationTechnologies: return "img";
144 case MipsTechnologies: return "mti";
145 case NVIDIA: return "nvidia";
146 case CSR: return "csr";
149 llvm_unreachable("Invalid VendorType!");
152 const char *Triple::getOSTypeName(OSType Kind) {
154 case UnknownOS: return "unknown";
156 case CloudABI: return "cloudabi";
157 case Darwin: return "darwin";
158 case DragonFly: return "dragonfly";
159 case FreeBSD: return "freebsd";
160 case IOS: return "ios";
161 case KFreeBSD: return "kfreebsd";
162 case Linux: return "linux";
163 case Lv2: return "lv2";
164 case MacOSX: return "macosx";
165 case NetBSD: return "netbsd";
166 case OpenBSD: return "openbsd";
167 case Solaris: return "solaris";
168 case Win32: return "windows";
169 case Haiku: return "haiku";
170 case Minix: return "minix";
171 case RTEMS: return "rtems";
172 case NaCl: return "nacl";
173 case CNK: return "cnk";
174 case Bitrig: return "bitrig";
175 case AIX: return "aix";
176 case CUDA: return "cuda";
177 case NVCL: return "nvcl";
178 case AMDHSA: return "amdhsa";
179 case PS4: return "ps4";
182 llvm_unreachable("Invalid OSType");
185 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
187 case UnknownEnvironment: return "unknown";
188 case GNU: return "gnu";
189 case GNUEABIHF: return "gnueabihf";
190 case GNUEABI: return "gnueabi";
191 case GNUX32: return "gnux32";
192 case CODE16: return "code16";
193 case EABI: return "eabi";
194 case EABIHF: return "eabihf";
195 case Android: return "android";
196 case MSVC: return "msvc";
197 case Itanium: return "itanium";
198 case Cygnus: return "cygnus";
199 case AMDOpenCL: return "amdopencl";
200 case CoreCLR: return "coreclr";
203 llvm_unreachable("Invalid EnvironmentType!");
206 static Triple::ArchType parseBPFArch(StringRef ArchName) {
207 if (ArchName.equals("bpf")) {
208 if (sys::IsLittleEndianHost)
209 return Triple::bpfel;
211 return Triple::bpfeb;
212 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
213 return Triple::bpfeb;
214 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
215 return Triple::bpfel;
217 return Triple::UnknownArch;
221 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
222 Triple::ArchType BPFArch(parseBPFArch(Name));
223 return StringSwitch<Triple::ArchType>(Name)
224 .Case("aarch64", aarch64)
225 .Case("aarch64_be", aarch64_be)
226 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
228 .Case("armeb", armeb)
229 .StartsWith("bpf", BPFArch)
231 .Case("mipsel", mipsel)
232 .Case("mips64", mips64)
233 .Case("mips64el", mips64el)
234 .Case("msp430", msp430)
235 .Case("ppc64", ppc64)
238 .Case("ppc64le", ppc64le)
240 .Case("amdgcn", amdgcn)
241 .Case("hexagon", hexagon)
242 .Case("sparc", sparc)
243 .Case("sparcel", sparcel)
244 .Case("sparcv9", sparcv9)
245 .Case("systemz", systemz)
247 .Case("thumb", thumb)
248 .Case("thumbeb", thumbeb)
250 .Case("x86-64", x86_64)
251 .Case("xcore", xcore)
252 .Case("nvptx", nvptx)
253 .Case("nvptx64", nvptx64)
256 .Case("amdil", amdil)
257 .Case("amdil64", amdil64)
258 .Case("hsail", hsail)
259 .Case("hsail64", hsail64)
261 .Case("spir64", spir64)
262 .Case("kalimba", kalimba)
263 .Case("shave", shave)
264 .Case("wasm32", wasm32)
265 .Case("wasm64", wasm64)
266 .Default(UnknownArch);
269 static Triple::ArchType parseARMArch(StringRef ArchName) {
270 unsigned ISA = ARM::parseArchISA(ArchName);
271 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
273 Triple::ArchType arch = Triple::UnknownArch;
275 case ARM::EK_LITTLE: {
281 arch = Triple::thumb;
283 case ARM::IK_AARCH64:
284 arch = Triple::aarch64;
292 arch = Triple::armeb;
295 arch = Triple::thumbeb;
297 case ARM::IK_AARCH64:
298 arch = Triple::aarch64_be;
305 ArchName = ARM::getCanonicalArchName(ArchName);
306 if (ArchName.empty())
307 return Triple::UnknownArch;
309 // Thumb only exists in v4+
310 if (ISA == ARM::IK_THUMB &&
311 (ArchName.startswith("v2") || ArchName.startswith("v3")))
312 return Triple::UnknownArch;
314 // Thumb only for v6m
315 unsigned Profile = ARM::parseArchProfile(ArchName);
316 unsigned Version = ARM::parseArchVersion(ArchName);
317 if (Profile == ARM::PK_M && Version == 6) {
318 if (ENDIAN == ARM::EK_BIG)
319 return Triple::thumbeb;
321 return Triple::thumb;
327 static Triple::ArchType parseArch(StringRef ArchName) {
328 Triple::ArchType ARMArch(parseARMArch(ArchName));
329 Triple::ArchType BPFArch(parseBPFArch(ArchName));
331 return StringSwitch<Triple::ArchType>(ArchName)
332 .Cases("i386", "i486", "i586", "i686", Triple::x86)
333 // FIXME: Do we need to support these?
334 .Cases("i786", "i886", "i986", Triple::x86)
335 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
336 .Case("powerpc", Triple::ppc)
337 .Cases("powerpc64", "ppu", Triple::ppc64)
338 .Case("powerpc64le", Triple::ppc64le)
339 .Case("xscale", Triple::arm)
340 .Case("xscaleeb", Triple::armeb)
341 .StartsWith("arm", ARMArch)
342 .StartsWith("thumb", ARMArch)
343 .StartsWith("aarch64", ARMArch)
344 .Case("msp430", Triple::msp430)
345 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
346 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
347 .Cases("mips64", "mips64eb", Triple::mips64)
348 .Case("mips64el", Triple::mips64el)
349 .Case("r600", Triple::r600)
350 .Case("amdgcn", Triple::amdgcn)
351 .StartsWith("bpf", BPFArch)
352 .Case("hexagon", Triple::hexagon)
353 .Case("s390x", Triple::systemz)
354 .Case("sparc", Triple::sparc)
355 .Case("sparcel", Triple::sparcel)
356 .Cases("sparcv9", "sparc64", Triple::sparcv9)
357 .Case("tce", Triple::tce)
358 .Case("xcore", Triple::xcore)
359 .Case("nvptx", Triple::nvptx)
360 .Case("nvptx64", Triple::nvptx64)
361 .Case("le32", Triple::le32)
362 .Case("le64", Triple::le64)
363 .Case("amdil", Triple::amdil)
364 .Case("amdil64", Triple::amdil64)
365 .Case("hsail", Triple::hsail)
366 .Case("hsail64", Triple::hsail64)
367 .Case("spir", Triple::spir)
368 .Case("spir64", Triple::spir64)
369 .StartsWith("kalimba", Triple::kalimba)
370 .Case("shave", Triple::shave)
371 .Case("wasm32", Triple::wasm32)
372 .Case("wasm64", Triple::wasm64)
373 .Default(Triple::UnknownArch);
376 static Triple::VendorType parseVendor(StringRef VendorName) {
377 return StringSwitch<Triple::VendorType>(VendorName)
378 .Case("apple", Triple::Apple)
379 .Case("pc", Triple::PC)
380 .Case("scei", Triple::SCEI)
381 .Case("bgp", Triple::BGP)
382 .Case("bgq", Triple::BGQ)
383 .Case("fsl", Triple::Freescale)
384 .Case("ibm", Triple::IBM)
385 .Case("img", Triple::ImaginationTechnologies)
386 .Case("mti", Triple::MipsTechnologies)
387 .Case("nvidia", Triple::NVIDIA)
388 .Case("csr", Triple::CSR)
389 .Default(Triple::UnknownVendor);
392 static Triple::OSType parseOS(StringRef OSName) {
393 return StringSwitch<Triple::OSType>(OSName)
394 .StartsWith("cloudabi", Triple::CloudABI)
395 .StartsWith("darwin", Triple::Darwin)
396 .StartsWith("dragonfly", Triple::DragonFly)
397 .StartsWith("freebsd", Triple::FreeBSD)
398 .StartsWith("ios", Triple::IOS)
399 .StartsWith("kfreebsd", Triple::KFreeBSD)
400 .StartsWith("linux", Triple::Linux)
401 .StartsWith("lv2", Triple::Lv2)
402 .StartsWith("macosx", Triple::MacOSX)
403 .StartsWith("netbsd", Triple::NetBSD)
404 .StartsWith("openbsd", Triple::OpenBSD)
405 .StartsWith("solaris", Triple::Solaris)
406 .StartsWith("win32", Triple::Win32)
407 .StartsWith("windows", Triple::Win32)
408 .StartsWith("haiku", Triple::Haiku)
409 .StartsWith("minix", Triple::Minix)
410 .StartsWith("rtems", Triple::RTEMS)
411 .StartsWith("nacl", Triple::NaCl)
412 .StartsWith("cnk", Triple::CNK)
413 .StartsWith("bitrig", Triple::Bitrig)
414 .StartsWith("aix", Triple::AIX)
415 .StartsWith("cuda", Triple::CUDA)
416 .StartsWith("nvcl", Triple::NVCL)
417 .StartsWith("amdhsa", Triple::AMDHSA)
418 .StartsWith("ps4", Triple::PS4)
419 .Default(Triple::UnknownOS);
422 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
423 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
424 .StartsWith("eabihf", Triple::EABIHF)
425 .StartsWith("eabi", Triple::EABI)
426 .StartsWith("gnueabihf", Triple::GNUEABIHF)
427 .StartsWith("gnueabi", Triple::GNUEABI)
428 .StartsWith("gnux32", Triple::GNUX32)
429 .StartsWith("code16", Triple::CODE16)
430 .StartsWith("gnu", Triple::GNU)
431 .StartsWith("android", Triple::Android)
432 .StartsWith("msvc", Triple::MSVC)
433 .StartsWith("itanium", Triple::Itanium)
434 .StartsWith("cygnus", Triple::Cygnus)
435 .StartsWith("amdopencl", Triple::AMDOpenCL)
436 .StartsWith("coreclr", Triple::CoreCLR)
437 .Default(Triple::UnknownEnvironment);
440 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
441 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
442 .EndsWith("coff", Triple::COFF)
443 .EndsWith("elf", Triple::ELF)
444 .EndsWith("macho", Triple::MachO)
445 .Default(Triple::UnknownObjectFormat);
448 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
449 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
451 // For now, this is the small part. Early return.
452 if (ARMSubArch.empty())
453 return StringSwitch<Triple::SubArchType>(SubArchName)
454 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
455 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
456 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
457 .Default(Triple::NoSubArch);
460 switch(ARM::parseArch(ARMSubArch)) {
462 return Triple::NoSubArch;
464 return Triple::ARMSubArch_v4t;
468 return Triple::ARMSubArch_v5;
469 case ARM::AK_ARMV5TE:
471 case ARM::AK_IWMMXT2:
473 case ARM::AK_ARMV5TEJ:
474 return Triple::ARMSubArch_v5te;
478 return Triple::ARMSubArch_v6;
480 case ARM::AK_ARMV6ZK:
481 case ARM::AK_ARMV6HL:
482 return Triple::ARMSubArch_v6k;
483 case ARM::AK_ARMV6T2:
484 return Triple::ARMSubArch_v6t2;
486 case ARM::AK_ARMV6SM:
487 return Triple::ARMSubArch_v6m;
492 case ARM::AK_ARMV7HL:
493 return Triple::ARMSubArch_v7;
495 return Triple::ARMSubArch_v7m;
497 return Triple::ARMSubArch_v7s;
498 case ARM::AK_ARMV7EM:
499 return Triple::ARMSubArch_v7em;
501 return Triple::ARMSubArch_v8;
502 case ARM::AK_ARMV8_1A:
503 return Triple::ARMSubArch_v8_1a;
505 return Triple::NoSubArch;
509 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
511 case Triple::UnknownObjectFormat: return "";
512 case Triple::COFF: return "coff";
513 case Triple::ELF: return "elf";
514 case Triple::MachO: return "macho";
516 llvm_unreachable("unknown object format type");
519 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
520 switch (T.getArch()) {
523 case Triple::hexagon:
527 case Triple::mips64el:
531 case Triple::sparcv9:
532 case Triple::systemz:
534 case Triple::ppc64le:
540 return Triple::MachO;
545 // Unknown for now, until an object format is specified.
546 return Triple::UnknownObjectFormat;
550 return Triple::MachO;
551 else if (T.isOSWindows())
556 /// \brief Construct a triple from the string representation provided.
558 /// This stores the string representation and parses the various pieces into
560 Triple::Triple(const Twine &Str)
562 Arch(parseArch(getArchName())),
563 SubArch(parseSubArch(getArchName())),
564 Vendor(parseVendor(getVendorName())),
565 OS(parseOS(getOSName())),
566 Environment(parseEnvironment(getEnvironmentName())),
567 ObjectFormat(parseFormat(getEnvironmentName())) {
568 if (ObjectFormat == Triple::UnknownObjectFormat)
569 ObjectFormat = getDefaultFormat(*this);
572 /// \brief Construct a triple from string representations of the architecture,
575 /// This joins each argument into a canonical string representation and parses
576 /// them into enum members. It leaves the environment unknown and omits it from
577 /// the string representation.
578 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
579 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
580 Arch(parseArch(ArchStr.str())),
581 SubArch(parseSubArch(ArchStr.str())),
582 Vendor(parseVendor(VendorStr.str())),
583 OS(parseOS(OSStr.str())),
584 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
585 ObjectFormat = getDefaultFormat(*this);
588 /// \brief Construct a triple from string representations of the architecture,
589 /// vendor, OS, and environment.
591 /// This joins each argument into a canonical string representation and parses
592 /// them into enum members.
593 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
594 const Twine &EnvironmentStr)
595 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
596 EnvironmentStr).str()),
597 Arch(parseArch(ArchStr.str())),
598 SubArch(parseSubArch(ArchStr.str())),
599 Vendor(parseVendor(VendorStr.str())),
600 OS(parseOS(OSStr.str())),
601 Environment(parseEnvironment(EnvironmentStr.str())),
602 ObjectFormat(parseFormat(EnvironmentStr.str())) {
603 if (ObjectFormat == Triple::UnknownObjectFormat)
604 ObjectFormat = getDefaultFormat(*this);
607 std::string Triple::normalize(StringRef Str) {
608 bool IsMinGW32 = false;
609 bool IsCygwin = false;
611 // Parse into components.
612 SmallVector<StringRef, 4> Components;
613 Str.split(Components, "-");
615 // If the first component corresponds to a known architecture, preferentially
616 // use it for the architecture. If the second component corresponds to a
617 // known vendor, preferentially use it for the vendor, etc. This avoids silly
618 // component movement when a component parses as (eg) both a valid arch and a
620 ArchType Arch = UnknownArch;
621 if (Components.size() > 0)
622 Arch = parseArch(Components[0]);
623 VendorType Vendor = UnknownVendor;
624 if (Components.size() > 1)
625 Vendor = parseVendor(Components[1]);
626 OSType OS = UnknownOS;
627 if (Components.size() > 2) {
628 OS = parseOS(Components[2]);
629 IsCygwin = Components[2].startswith("cygwin");
630 IsMinGW32 = Components[2].startswith("mingw");
632 EnvironmentType Environment = UnknownEnvironment;
633 if (Components.size() > 3)
634 Environment = parseEnvironment(Components[3]);
635 ObjectFormatType ObjectFormat = UnknownObjectFormat;
636 if (Components.size() > 4)
637 ObjectFormat = parseFormat(Components[4]);
639 // Note which components are already in their final position. These will not
642 Found[0] = Arch != UnknownArch;
643 Found[1] = Vendor != UnknownVendor;
644 Found[2] = OS != UnknownOS;
645 Found[3] = Environment != UnknownEnvironment;
647 // If they are not there already, permute the components into their canonical
648 // positions by seeing if they parse as a valid architecture, and if so moving
649 // the component to the architecture position etc.
650 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
652 continue; // Already in the canonical position.
654 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
655 // Do not reparse any components that already matched.
656 if (Idx < array_lengthof(Found) && Found[Idx])
659 // Does this component parse as valid for the target position?
661 StringRef Comp = Components[Idx];
663 default: llvm_unreachable("unexpected component type!");
665 Arch = parseArch(Comp);
666 Valid = Arch != UnknownArch;
669 Vendor = parseVendor(Comp);
670 Valid = Vendor != UnknownVendor;
674 IsCygwin = Comp.startswith("cygwin");
675 IsMinGW32 = Comp.startswith("mingw");
676 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
679 Environment = parseEnvironment(Comp);
680 Valid = Environment != UnknownEnvironment;
682 ObjectFormat = parseFormat(Comp);
683 Valid = ObjectFormat != UnknownObjectFormat;
688 continue; // Nope, try the next component.
690 // Move the component to the target position, pushing any non-fixed
691 // components that are in the way to the right. This tends to give
692 // good results in the common cases of a forgotten vendor component
693 // or a wrongly positioned environment.
695 // Insert left, pushing the existing components to the right. For
696 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
697 StringRef CurrentComponent(""); // The empty component.
698 // Replace the component we are moving with an empty component.
699 std::swap(CurrentComponent, Components[Idx]);
700 // Insert the component being moved at Pos, displacing any existing
701 // components to the right.
702 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
703 // Skip over any fixed components.
704 while (i < array_lengthof(Found) && Found[i])
706 // Place the component at the new position, getting the component
707 // that was at this position - it will be moved right.
708 std::swap(CurrentComponent, Components[i]);
710 } else if (Pos > Idx) {
711 // Push right by inserting empty components until the component at Idx
712 // reaches the target position Pos. For example, pc-a -> -pc-a when
713 // moving pc to the second position.
715 // Insert one empty component at Idx.
716 StringRef CurrentComponent(""); // The empty component.
717 for (unsigned i = Idx; i < Components.size();) {
718 // Place the component at the new position, getting the component
719 // that was at this position - it will be moved right.
720 std::swap(CurrentComponent, Components[i]);
721 // If it was placed on top of an empty component then we are done.
722 if (CurrentComponent.empty())
724 // Advance to the next component, skipping any fixed components.
725 while (++i < array_lengthof(Found) && Found[i])
728 // The last component was pushed off the end - append it.
729 if (!CurrentComponent.empty())
730 Components.push_back(CurrentComponent);
732 // Advance Idx to the component's new position.
733 while (++Idx < array_lengthof(Found) && Found[Idx])
735 } while (Idx < Pos); // Add more until the final position is reached.
737 assert(Pos < Components.size() && Components[Pos] == Comp &&
738 "Component moved wrong!");
744 // Special case logic goes here. At this point Arch, Vendor and OS have the
745 // correct values for the computed components.
746 std::string NormalizedEnvironment;
747 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
748 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
749 if (AndroidVersion.empty()) {
750 Components[3] = "android";
752 NormalizedEnvironment = Twine("android", AndroidVersion).str();
753 Components[3] = NormalizedEnvironment;
757 if (OS == Triple::Win32) {
758 Components.resize(4);
759 Components[2] = "windows";
760 if (Environment == UnknownEnvironment) {
761 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
762 Components[3] = "msvc";
764 Components[3] = getObjectFormatTypeName(ObjectFormat);
766 } else if (IsMinGW32) {
767 Components.resize(4);
768 Components[2] = "windows";
769 Components[3] = "gnu";
770 } else if (IsCygwin) {
771 Components.resize(4);
772 Components[2] = "windows";
773 Components[3] = "cygnus";
775 if (IsMinGW32 || IsCygwin ||
776 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
777 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
778 Components.resize(5);
779 Components[4] = getObjectFormatTypeName(ObjectFormat);
783 // Stick the corrected components back together to form the normalized string.
784 std::string Normalized;
785 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
786 if (i) Normalized += '-';
787 Normalized += Components[i];
792 StringRef Triple::getArchName() const {
793 return StringRef(Data).split('-').first; // Isolate first component
796 StringRef Triple::getVendorName() const {
797 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
798 return Tmp.split('-').first; // Isolate second component
801 StringRef Triple::getOSName() const {
802 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
803 Tmp = Tmp.split('-').second; // Strip second component
804 return Tmp.split('-').first; // Isolate third component
807 StringRef Triple::getEnvironmentName() const {
808 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
809 Tmp = Tmp.split('-').second; // Strip second component
810 return Tmp.split('-').second; // Strip third component
813 StringRef Triple::getOSAndEnvironmentName() const {
814 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
815 return Tmp.split('-').second; // Strip second component
818 static unsigned EatNumber(StringRef &Str) {
819 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
823 // Consume the leading digit.
824 Result = Result*10 + (Str[0] - '0');
828 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
833 static void parseVersionFromName(StringRef Name, unsigned &Major,
834 unsigned &Minor, unsigned &Micro) {
835 // Any unset version defaults to 0.
836 Major = Minor = Micro = 0;
838 // Parse up to three components.
839 unsigned *Components[3] = {&Major, &Minor, &Micro};
840 for (unsigned i = 0; i != 3; ++i) {
841 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
844 // Consume the leading number.
845 *Components[i] = EatNumber(Name);
847 // Consume the separator, if present.
848 if (Name.startswith("."))
849 Name = Name.substr(1);
853 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
854 unsigned &Micro) const {
855 StringRef EnvironmentName = getEnvironmentName();
856 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
857 if (EnvironmentName.startswith(EnvironmentTypeName))
858 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
860 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
863 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
864 unsigned &Micro) const {
865 StringRef OSName = getOSName();
866 // Assume that the OS portion of the triple starts with the canonical name.
867 StringRef OSTypeName = getOSTypeName(getOS());
868 if (OSName.startswith(OSTypeName))
869 OSName = OSName.substr(OSTypeName.size());
871 parseVersionFromName(OSName, Major, Minor, Micro);
874 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
875 unsigned &Micro) const {
876 getOSVersion(Major, Minor, Micro);
879 default: llvm_unreachable("unexpected OS for Darwin triple");
881 // Default to darwin8, i.e., MacOSX 10.4.
884 // Darwin version numbers are skewed from OS X versions.
901 // Ignore the version from the triple. This is only handled because the
902 // the clang driver combines OS X and IOS support into a common Darwin
903 // toolchain that wants to know the OS X version number even when targeting
913 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
914 unsigned &Micro) const {
916 default: llvm_unreachable("unexpected OS for Darwin triple");
919 // Ignore the version from the triple. This is only handled because the
920 // the clang driver combines OS X and IOS support into a common Darwin
921 // toolchain that wants to know the iOS version number even when targeting
928 getOSVersion(Major, Minor, Micro);
929 // Default to 5.0 (or 7.0 for arm64).
931 Major = (getArch() == aarch64) ? 7 : 5;
936 void Triple::setTriple(const Twine &Str) {
940 void Triple::setArch(ArchType Kind) {
941 setArchName(getArchTypeName(Kind));
944 void Triple::setVendor(VendorType Kind) {
945 setVendorName(getVendorTypeName(Kind));
948 void Triple::setOS(OSType Kind) {
949 setOSName(getOSTypeName(Kind));
952 void Triple::setEnvironment(EnvironmentType Kind) {
953 if (ObjectFormat == getDefaultFormat(*this))
954 return setEnvironmentName(getEnvironmentTypeName(Kind));
956 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
957 getObjectFormatTypeName(ObjectFormat)).str());
960 void Triple::setObjectFormat(ObjectFormatType Kind) {
961 if (Environment == UnknownEnvironment)
962 return setEnvironmentName(getObjectFormatTypeName(Kind));
964 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
965 getObjectFormatTypeName(Kind)).str());
968 void Triple::setArchName(StringRef Str) {
969 // Work around a miscompilation bug for Twines in gcc 4.0.3.
970 SmallString<64> Triple;
973 Triple += getVendorName();
975 Triple += getOSAndEnvironmentName();
979 void Triple::setVendorName(StringRef Str) {
980 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
983 void Triple::setOSName(StringRef Str) {
984 if (hasEnvironment())
985 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
986 "-" + getEnvironmentName());
988 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
991 void Triple::setEnvironmentName(StringRef Str) {
992 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
996 void Triple::setOSAndEnvironmentName(StringRef Str) {
997 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1000 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1002 case llvm::Triple::UnknownArch:
1005 case llvm::Triple::msp430:
1008 case llvm::Triple::arm:
1009 case llvm::Triple::armeb:
1010 case llvm::Triple::hexagon:
1011 case llvm::Triple::le32:
1012 case llvm::Triple::mips:
1013 case llvm::Triple::mipsel:
1014 case llvm::Triple::nvptx:
1015 case llvm::Triple::ppc:
1016 case llvm::Triple::r600:
1017 case llvm::Triple::sparc:
1018 case llvm::Triple::sparcel:
1019 case llvm::Triple::tce:
1020 case llvm::Triple::thumb:
1021 case llvm::Triple::thumbeb:
1022 case llvm::Triple::x86:
1023 case llvm::Triple::xcore:
1024 case llvm::Triple::amdil:
1025 case llvm::Triple::hsail:
1026 case llvm::Triple::spir:
1027 case llvm::Triple::kalimba:
1028 case llvm::Triple::shave:
1029 case llvm::Triple::wasm32:
1032 case llvm::Triple::aarch64:
1033 case llvm::Triple::aarch64_be:
1034 case llvm::Triple::amdgcn:
1035 case llvm::Triple::bpfel:
1036 case llvm::Triple::bpfeb:
1037 case llvm::Triple::le64:
1038 case llvm::Triple::mips64:
1039 case llvm::Triple::mips64el:
1040 case llvm::Triple::nvptx64:
1041 case llvm::Triple::ppc64:
1042 case llvm::Triple::ppc64le:
1043 case llvm::Triple::sparcv9:
1044 case llvm::Triple::systemz:
1045 case llvm::Triple::x86_64:
1046 case llvm::Triple::amdil64:
1047 case llvm::Triple::hsail64:
1048 case llvm::Triple::spir64:
1049 case llvm::Triple::wasm64:
1052 llvm_unreachable("Invalid architecture value");
1055 bool Triple::isArch64Bit() const {
1056 return getArchPointerBitWidth(getArch()) == 64;
1059 bool Triple::isArch32Bit() const {
1060 return getArchPointerBitWidth(getArch()) == 32;
1063 bool Triple::isArch16Bit() const {
1064 return getArchPointerBitWidth(getArch()) == 16;
1067 Triple Triple::get32BitArchVariant() const {
1069 switch (getArch()) {
1070 case Triple::UnknownArch:
1071 case Triple::aarch64:
1072 case Triple::aarch64_be:
1073 case Triple::amdgcn:
1076 case Triple::msp430:
1077 case Triple::systemz:
1078 case Triple::ppc64le:
1079 T.setArch(UnknownArch);
1087 case Triple::hexagon:
1088 case Triple::kalimba:
1091 case Triple::mipsel:
1096 case Triple::sparcel:
1099 case Triple::thumbeb:
1103 case Triple::wasm32:
1107 case Triple::le64: T.setArch(Triple::le32); break;
1108 case Triple::mips64: T.setArch(Triple::mips); break;
1109 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1110 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1111 case Triple::ppc64: T.setArch(Triple::ppc); break;
1112 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1113 case Triple::x86_64: T.setArch(Triple::x86); break;
1114 case Triple::amdil64: T.setArch(Triple::amdil); break;
1115 case Triple::hsail64: T.setArch(Triple::hsail); break;
1116 case Triple::spir64: T.setArch(Triple::spir); break;
1117 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1122 Triple Triple::get64BitArchVariant() const {
1124 switch (getArch()) {
1125 case Triple::UnknownArch:
1128 case Triple::hexagon:
1129 case Triple::kalimba:
1130 case Triple::msp430:
1134 case Triple::thumbeb:
1136 case Triple::sparcel:
1138 T.setArch(UnknownArch);
1141 case Triple::aarch64:
1142 case Triple::aarch64_be:
1146 case Triple::amdil64:
1147 case Triple::amdgcn:
1148 case Triple::hsail64:
1149 case Triple::spir64:
1150 case Triple::mips64:
1151 case Triple::mips64el:
1152 case Triple::nvptx64:
1154 case Triple::ppc64le:
1155 case Triple::sparcv9:
1156 case Triple::systemz:
1157 case Triple::x86_64:
1158 case Triple::wasm64:
1162 case Triple::le32: T.setArch(Triple::le64); break;
1163 case Triple::mips: T.setArch(Triple::mips64); break;
1164 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1165 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1166 case Triple::ppc: T.setArch(Triple::ppc64); break;
1167 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1168 case Triple::x86: T.setArch(Triple::x86_64); break;
1169 case Triple::amdil: T.setArch(Triple::amdil64); break;
1170 case Triple::hsail: T.setArch(Triple::hsail64); break;
1171 case Triple::spir: T.setArch(Triple::spir64); break;
1172 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1177 Triple Triple::getBigEndianArchVariant() const {
1179 switch (getArch()) {
1180 case Triple::UnknownArch:
1181 case Triple::amdgcn:
1182 case Triple::amdil64:
1184 case Triple::hexagon:
1185 case Triple::hsail64:
1187 case Triple::kalimba:
1190 case Triple::msp430:
1191 case Triple::nvptx64:
1195 case Triple::spir64:
1197 case Triple::wasm32:
1198 case Triple::wasm64:
1200 case Triple::x86_64:
1203 // ARM is intentionally unsupported here, changing the architecture would
1204 // drop any arch suffixes.
1207 T.setArch(UnknownArch);
1210 case Triple::aarch64_be:
1213 case Triple::mips64:
1218 case Triple::sparcv9:
1219 case Triple::systemz:
1221 case Triple::thumbeb:
1222 // Already big endian.
1225 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1226 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1227 case Triple::mips64el:T.setArch(Triple::mips64); break;
1228 case Triple::mipsel: T.setArch(Triple::mips); break;
1229 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1230 case Triple::sparcel: T.setArch(Triple::sparc); break;
1235 Triple Triple::getLittleEndianArchVariant() const {
1237 switch (getArch()) {
1238 case Triple::UnknownArch:
1240 case Triple::sparcv9:
1241 case Triple::systemz:
1244 // ARM is intentionally unsupported here, changing the architecture would
1245 // drop any arch suffixes.
1247 case Triple::thumbeb:
1248 T.setArch(UnknownArch);
1251 case Triple::aarch64:
1252 case Triple::amdgcn:
1253 case Triple::amdil64:
1257 case Triple::hexagon:
1258 case Triple::hsail64:
1260 case Triple::kalimba:
1263 case Triple::mips64el:
1264 case Triple::mipsel:
1265 case Triple::msp430:
1266 case Triple::nvptx64:
1268 case Triple::ppc64le:
1271 case Triple::sparcel:
1272 case Triple::spir64:
1275 case Triple::wasm32:
1276 case Triple::wasm64:
1278 case Triple::x86_64:
1280 // Already little endian.
1283 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1284 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1285 case Triple::mips64: T.setArch(Triple::mips64el); break;
1286 case Triple::mips: T.setArch(Triple::mipsel); break;
1287 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1288 case Triple::sparc: T.setArch(Triple::sparcel); break;
1293 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1295 MArch = getArchName();
1296 MArch = ARM::getCanonicalArchName(MArch);
1298 // Some defaults are forced.
1300 case llvm::Triple::FreeBSD:
1301 case llvm::Triple::NetBSD:
1302 if (!MArch.empty() && MArch == "v6")
1303 return "arm1176jzf-s";
1305 case llvm::Triple::Win32:
1306 // FIXME: this is invalid for WindowsCE
1315 StringRef CPU = ARM::getDefaultCPU(MArch);
1319 // If no specific architecture version is requested, return the minimum CPU
1320 // required by the OS and environment.
1322 case llvm::Triple::NetBSD:
1323 switch (getEnvironment()) {
1324 case llvm::Triple::GNUEABIHF:
1325 case llvm::Triple::GNUEABI:
1326 case llvm::Triple::EABIHF:
1327 case llvm::Triple::EABI:
1328 return "arm926ej-s";
1332 case llvm::Triple::NaCl:
1335 switch (getEnvironment()) {
1336 case llvm::Triple::EABIHF:
1337 case llvm::Triple::GNUEABIHF:
1338 return "arm1176jzf-s";
1344 llvm_unreachable("invalid arch name");