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";
127 case wasm32: return "wasm32";
128 case wasm64: return "wasm64";
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";
202 llvm_unreachable("Invalid EnvironmentType!");
205 static Triple::ArchType parseBPFArch(StringRef ArchName) {
206 if (ArchName.equals("bpf")) {
207 if (sys::IsLittleEndianHost)
208 return Triple::bpfel;
210 return Triple::bpfeb;
211 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
212 return Triple::bpfeb;
213 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
214 return Triple::bpfel;
216 return Triple::UnknownArch;
220 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
221 Triple::ArchType BPFArch(parseBPFArch(Name));
222 return StringSwitch<Triple::ArchType>(Name)
223 .Case("aarch64", aarch64)
224 .Case("aarch64_be", aarch64_be)
225 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
227 .Case("armeb", armeb)
228 .StartsWith("bpf", BPFArch)
230 .Case("mipsel", mipsel)
231 .Case("mips64", mips64)
232 .Case("mips64el", mips64el)
233 .Case("msp430", msp430)
234 .Case("ppc64", ppc64)
237 .Case("ppc64le", ppc64le)
239 .Case("amdgcn", amdgcn)
240 .Case("hexagon", hexagon)
241 .Case("sparc", sparc)
242 .Case("sparcel", sparcel)
243 .Case("sparcv9", sparcv9)
244 .Case("systemz", systemz)
246 .Case("thumb", thumb)
247 .Case("thumbeb", thumbeb)
249 .Case("x86-64", x86_64)
250 .Case("xcore", xcore)
251 .Case("nvptx", nvptx)
252 .Case("nvptx64", nvptx64)
255 .Case("amdil", amdil)
256 .Case("amdil64", amdil64)
257 .Case("hsail", hsail)
258 .Case("hsail64", hsail64)
260 .Case("spir64", spir64)
261 .Case("kalimba", kalimba)
262 .Case("shave", shave)
263 .Case("wasm32", wasm32)
264 .Case("wasm64", wasm64)
265 .Default(UnknownArch);
268 static Triple::ArchType parseARMArch(StringRef ArchName) {
269 unsigned ISA = ARMTargetParser::parseArchISA(ArchName);
270 unsigned ENDIAN = ARMTargetParser::parseArchEndian(ArchName);
272 Triple::ArchType arch = Triple::UnknownArch;
274 case ARM::EK_LITTLE: {
280 arch = Triple::thumb;
282 case ARM::IK_AARCH64:
283 arch = Triple::aarch64;
291 arch = Triple::armeb;
294 arch = Triple::thumbeb;
296 case ARM::IK_AARCH64:
297 arch = Triple::aarch64_be;
304 ArchName = ARMTargetParser::getCanonicalArchName(ArchName);
305 if (ArchName.empty())
306 return Triple::UnknownArch;
308 // Thumb only exists in v4+
309 if (ISA == ARM::IK_THUMB &&
310 (ArchName.startswith("v2") || ArchName.startswith("v3")))
311 return Triple::UnknownArch;
313 // Thumb only for v6m
314 unsigned Profile = ARMTargetParser::parseArchProfile(ArchName);
315 unsigned Version = ARMTargetParser::parseArchVersion(ArchName);
316 if (Profile == ARM::PK_M && Version == 6) {
317 if (ENDIAN == ARM::EK_BIG)
318 return Triple::thumbeb;
320 return Triple::thumb;
326 static Triple::ArchType parseArch(StringRef ArchName) {
327 Triple::ArchType ARMArch(parseARMArch(ArchName));
328 Triple::ArchType BPFArch(parseBPFArch(ArchName));
330 return StringSwitch<Triple::ArchType>(ArchName)
331 .Cases("i386", "i486", "i586", "i686", Triple::x86)
332 // FIXME: Do we need to support these?
333 .Cases("i786", "i886", "i986", Triple::x86)
334 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
335 .Case("powerpc", Triple::ppc)
336 .Cases("powerpc64", "ppu", Triple::ppc64)
337 .Case("powerpc64le", Triple::ppc64le)
338 .Case("xscale", Triple::arm)
339 .Case("xscaleeb", Triple::armeb)
340 .StartsWith("arm", ARMArch)
341 .StartsWith("thumb", ARMArch)
342 .StartsWith("aarch64", ARMArch)
343 .Case("msp430", Triple::msp430)
344 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
345 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
346 .Cases("mips64", "mips64eb", Triple::mips64)
347 .Case("mips64el", Triple::mips64el)
348 .Case("r600", Triple::r600)
349 .Case("amdgcn", Triple::amdgcn)
350 .StartsWith("bpf", BPFArch)
351 .Case("hexagon", Triple::hexagon)
352 .Case("s390x", Triple::systemz)
353 .Case("sparc", Triple::sparc)
354 .Case("sparcel", Triple::sparcel)
355 .Cases("sparcv9", "sparc64", Triple::sparcv9)
356 .Case("tce", Triple::tce)
357 .Case("xcore", Triple::xcore)
358 .Case("nvptx", Triple::nvptx)
359 .Case("nvptx64", Triple::nvptx64)
360 .Case("le32", Triple::le32)
361 .Case("le64", Triple::le64)
362 .Case("amdil", Triple::amdil)
363 .Case("amdil64", Triple::amdil64)
364 .Case("hsail", Triple::hsail)
365 .Case("hsail64", Triple::hsail64)
366 .Case("spir", Triple::spir)
367 .Case("spir64", Triple::spir64)
368 .StartsWith("kalimba", Triple::kalimba)
369 .Case("shave", Triple::shave)
370 .Case("wasm32", Triple::wasm32)
371 .Case("wasm64", Triple::wasm64)
372 .Default(Triple::UnknownArch);
375 static Triple::VendorType parseVendor(StringRef VendorName) {
376 return StringSwitch<Triple::VendorType>(VendorName)
377 .Case("apple", Triple::Apple)
378 .Case("pc", Triple::PC)
379 .Case("scei", Triple::SCEI)
380 .Case("bgp", Triple::BGP)
381 .Case("bgq", Triple::BGQ)
382 .Case("fsl", Triple::Freescale)
383 .Case("ibm", Triple::IBM)
384 .Case("img", Triple::ImaginationTechnologies)
385 .Case("mti", Triple::MipsTechnologies)
386 .Case("nvidia", Triple::NVIDIA)
387 .Case("csr", Triple::CSR)
388 .Default(Triple::UnknownVendor);
391 static Triple::OSType parseOS(StringRef OSName) {
392 return StringSwitch<Triple::OSType>(OSName)
393 .StartsWith("cloudabi", Triple::CloudABI)
394 .StartsWith("darwin", Triple::Darwin)
395 .StartsWith("dragonfly", Triple::DragonFly)
396 .StartsWith("freebsd", Triple::FreeBSD)
397 .StartsWith("ios", Triple::IOS)
398 .StartsWith("kfreebsd", Triple::KFreeBSD)
399 .StartsWith("linux", Triple::Linux)
400 .StartsWith("lv2", Triple::Lv2)
401 .StartsWith("macosx", Triple::MacOSX)
402 .StartsWith("netbsd", Triple::NetBSD)
403 .StartsWith("openbsd", Triple::OpenBSD)
404 .StartsWith("solaris", Triple::Solaris)
405 .StartsWith("win32", Triple::Win32)
406 .StartsWith("windows", Triple::Win32)
407 .StartsWith("haiku", Triple::Haiku)
408 .StartsWith("minix", Triple::Minix)
409 .StartsWith("rtems", Triple::RTEMS)
410 .StartsWith("nacl", Triple::NaCl)
411 .StartsWith("cnk", Triple::CNK)
412 .StartsWith("bitrig", Triple::Bitrig)
413 .StartsWith("aix", Triple::AIX)
414 .StartsWith("cuda", Triple::CUDA)
415 .StartsWith("nvcl", Triple::NVCL)
416 .StartsWith("amdhsa", Triple::AMDHSA)
417 .StartsWith("ps4", Triple::PS4)
418 .Default(Triple::UnknownOS);
421 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
422 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
423 .StartsWith("eabihf", Triple::EABIHF)
424 .StartsWith("eabi", Triple::EABI)
425 .StartsWith("gnueabihf", Triple::GNUEABIHF)
426 .StartsWith("gnueabi", Triple::GNUEABI)
427 .StartsWith("gnux32", Triple::GNUX32)
428 .StartsWith("code16", Triple::CODE16)
429 .StartsWith("gnu", Triple::GNU)
430 .StartsWith("android", Triple::Android)
431 .StartsWith("msvc", Triple::MSVC)
432 .StartsWith("itanium", Triple::Itanium)
433 .StartsWith("cygnus", Triple::Cygnus)
434 .StartsWith("amdopencl", Triple::AMDOpenCL)
435 .Default(Triple::UnknownEnvironment);
438 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
439 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
440 .EndsWith("coff", Triple::COFF)
441 .EndsWith("elf", Triple::ELF)
442 .EndsWith("macho", Triple::MachO)
443 .Default(Triple::UnknownObjectFormat);
446 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
447 StringRef ARMSubArch = ARMTargetParser::getCanonicalArchName(SubArchName);
449 // For now, this is the small part. Early return.
450 if (ARMSubArch.empty())
451 return StringSwitch<Triple::SubArchType>(SubArchName)
452 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
453 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
454 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
455 .Default(Triple::NoSubArch);
458 switch(ARMTargetParser::parseArch(ARMSubArch)) {
460 return Triple::NoSubArch;
462 return Triple::ARMSubArch_v4t;
466 return Triple::ARMSubArch_v5;
467 case ARM::AK_ARMV5TE:
469 case ARM::AK_IWMMXT2:
471 case ARM::AK_ARMV5TEJ:
472 return Triple::ARMSubArch_v5te;
476 return Triple::ARMSubArch_v6;
478 case ARM::AK_ARMV6ZK:
479 case ARM::AK_ARMV6HL:
480 return Triple::ARMSubArch_v6k;
481 case ARM::AK_ARMV6T2:
482 return Triple::ARMSubArch_v6t2;
484 case ARM::AK_ARMV6SM:
485 return Triple::ARMSubArch_v6m;
490 case ARM::AK_ARMV7HL:
491 return Triple::ARMSubArch_v7;
493 return Triple::ARMSubArch_v7m;
495 return Triple::ARMSubArch_v7s;
496 case ARM::AK_ARMV7EM:
497 return Triple::ARMSubArch_v7em;
499 return Triple::ARMSubArch_v8;
500 case ARM::AK_ARMV8_1A:
501 return Triple::ARMSubArch_v8_1a;
503 return Triple::NoSubArch;
507 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
509 case Triple::UnknownObjectFormat: return "";
510 case Triple::COFF: return "coff";
511 case Triple::ELF: return "elf";
512 case Triple::MachO: return "macho";
514 llvm_unreachable("unknown object format type");
517 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
518 switch (T.getArch()) {
521 case Triple::hexagon:
525 case Triple::mips64el:
529 case Triple::sparcv9:
530 case Triple::systemz:
532 case Triple::ppc64le:
538 return Triple::MachO;
543 return Triple::MachO;
544 else if (T.isOSWindows())
549 /// \brief Construct a triple from the string representation provided.
551 /// This stores the string representation and parses the various pieces into
553 Triple::Triple(const Twine &Str)
555 Arch(parseArch(getArchName())),
556 SubArch(parseSubArch(getArchName())),
557 Vendor(parseVendor(getVendorName())),
558 OS(parseOS(getOSName())),
559 Environment(parseEnvironment(getEnvironmentName())),
560 ObjectFormat(parseFormat(getEnvironmentName())) {
561 if (ObjectFormat == Triple::UnknownObjectFormat)
562 ObjectFormat = getDefaultFormat(*this);
565 /// \brief Construct a triple from string representations of the architecture,
568 /// This joins each argument into a canonical string representation and parses
569 /// them into enum members. It leaves the environment unknown and omits it from
570 /// the string representation.
571 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
572 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
573 Arch(parseArch(ArchStr.str())),
574 SubArch(parseSubArch(ArchStr.str())),
575 Vendor(parseVendor(VendorStr.str())),
576 OS(parseOS(OSStr.str())),
577 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
578 ObjectFormat = getDefaultFormat(*this);
581 /// \brief Construct a triple from string representations of the architecture,
582 /// vendor, OS, and environment.
584 /// This joins each argument into a canonical string representation and parses
585 /// them into enum members.
586 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
587 const Twine &EnvironmentStr)
588 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
589 EnvironmentStr).str()),
590 Arch(parseArch(ArchStr.str())),
591 SubArch(parseSubArch(ArchStr.str())),
592 Vendor(parseVendor(VendorStr.str())),
593 OS(parseOS(OSStr.str())),
594 Environment(parseEnvironment(EnvironmentStr.str())),
595 ObjectFormat(parseFormat(EnvironmentStr.str())) {
596 if (ObjectFormat == Triple::UnknownObjectFormat)
597 ObjectFormat = getDefaultFormat(*this);
600 std::string Triple::normalize(StringRef Str) {
601 bool IsMinGW32 = false;
602 bool IsCygwin = false;
604 // Parse into components.
605 SmallVector<StringRef, 4> Components;
606 Str.split(Components, "-");
608 // If the first component corresponds to a known architecture, preferentially
609 // use it for the architecture. If the second component corresponds to a
610 // known vendor, preferentially use it for the vendor, etc. This avoids silly
611 // component movement when a component parses as (eg) both a valid arch and a
613 ArchType Arch = UnknownArch;
614 if (Components.size() > 0)
615 Arch = parseArch(Components[0]);
616 VendorType Vendor = UnknownVendor;
617 if (Components.size() > 1)
618 Vendor = parseVendor(Components[1]);
619 OSType OS = UnknownOS;
620 if (Components.size() > 2) {
621 OS = parseOS(Components[2]);
622 IsCygwin = Components[2].startswith("cygwin");
623 IsMinGW32 = Components[2].startswith("mingw");
625 EnvironmentType Environment = UnknownEnvironment;
626 if (Components.size() > 3)
627 Environment = parseEnvironment(Components[3]);
628 ObjectFormatType ObjectFormat = UnknownObjectFormat;
629 if (Components.size() > 4)
630 ObjectFormat = parseFormat(Components[4]);
632 // Note which components are already in their final position. These will not
635 Found[0] = Arch != UnknownArch;
636 Found[1] = Vendor != UnknownVendor;
637 Found[2] = OS != UnknownOS;
638 Found[3] = Environment != UnknownEnvironment;
640 // If they are not there already, permute the components into their canonical
641 // positions by seeing if they parse as a valid architecture, and if so moving
642 // the component to the architecture position etc.
643 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
645 continue; // Already in the canonical position.
647 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
648 // Do not reparse any components that already matched.
649 if (Idx < array_lengthof(Found) && Found[Idx])
652 // Does this component parse as valid for the target position?
654 StringRef Comp = Components[Idx];
656 default: llvm_unreachable("unexpected component type!");
658 Arch = parseArch(Comp);
659 Valid = Arch != UnknownArch;
662 Vendor = parseVendor(Comp);
663 Valid = Vendor != UnknownVendor;
667 IsCygwin = Comp.startswith("cygwin");
668 IsMinGW32 = Comp.startswith("mingw");
669 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
672 Environment = parseEnvironment(Comp);
673 Valid = Environment != UnknownEnvironment;
675 ObjectFormat = parseFormat(Comp);
676 Valid = ObjectFormat != UnknownObjectFormat;
681 continue; // Nope, try the next component.
683 // Move the component to the target position, pushing any non-fixed
684 // components that are in the way to the right. This tends to give
685 // good results in the common cases of a forgotten vendor component
686 // or a wrongly positioned environment.
688 // Insert left, pushing the existing components to the right. For
689 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
690 StringRef CurrentComponent(""); // The empty component.
691 // Replace the component we are moving with an empty component.
692 std::swap(CurrentComponent, Components[Idx]);
693 // Insert the component being moved at Pos, displacing any existing
694 // components to the right.
695 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
696 // Skip over any fixed components.
697 while (i < array_lengthof(Found) && Found[i])
699 // Place the component at the new position, getting the component
700 // that was at this position - it will be moved right.
701 std::swap(CurrentComponent, Components[i]);
703 } else if (Pos > Idx) {
704 // Push right by inserting empty components until the component at Idx
705 // reaches the target position Pos. For example, pc-a -> -pc-a when
706 // moving pc to the second position.
708 // Insert one empty component at Idx.
709 StringRef CurrentComponent(""); // The empty component.
710 for (unsigned i = Idx; i < Components.size();) {
711 // Place the component at the new position, getting the component
712 // that was at this position - it will be moved right.
713 std::swap(CurrentComponent, Components[i]);
714 // If it was placed on top of an empty component then we are done.
715 if (CurrentComponent.empty())
717 // Advance to the next component, skipping any fixed components.
718 while (++i < array_lengthof(Found) && Found[i])
721 // The last component was pushed off the end - append it.
722 if (!CurrentComponent.empty())
723 Components.push_back(CurrentComponent);
725 // Advance Idx to the component's new position.
726 while (++Idx < array_lengthof(Found) && Found[Idx])
728 } while (Idx < Pos); // Add more until the final position is reached.
730 assert(Pos < Components.size() && Components[Pos] == Comp &&
731 "Component moved wrong!");
737 // Special case logic goes here. At this point Arch, Vendor and OS have the
738 // correct values for the computed components.
739 std::string NormalizedEnvironment;
740 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
741 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
742 if (AndroidVersion.empty()) {
743 Components[3] = "android";
745 NormalizedEnvironment = Twine("android", AndroidVersion).str();
746 Components[3] = NormalizedEnvironment;
750 if (OS == Triple::Win32) {
751 Components.resize(4);
752 Components[2] = "windows";
753 if (Environment == UnknownEnvironment) {
754 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
755 Components[3] = "msvc";
757 Components[3] = getObjectFormatTypeName(ObjectFormat);
759 } else if (IsMinGW32) {
760 Components.resize(4);
761 Components[2] = "windows";
762 Components[3] = "gnu";
763 } else if (IsCygwin) {
764 Components.resize(4);
765 Components[2] = "windows";
766 Components[3] = "cygnus";
768 if (IsMinGW32 || IsCygwin ||
769 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
770 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
771 Components.resize(5);
772 Components[4] = getObjectFormatTypeName(ObjectFormat);
776 // Stick the corrected components back together to form the normalized string.
777 std::string Normalized;
778 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
779 if (i) Normalized += '-';
780 Normalized += Components[i];
785 StringRef Triple::getArchName() const {
786 return StringRef(Data).split('-').first; // Isolate first component
789 StringRef Triple::getVendorName() const {
790 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
791 return Tmp.split('-').first; // Isolate second component
794 StringRef Triple::getOSName() const {
795 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
796 Tmp = Tmp.split('-').second; // Strip second component
797 return Tmp.split('-').first; // Isolate third component
800 StringRef Triple::getEnvironmentName() const {
801 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
802 Tmp = Tmp.split('-').second; // Strip second component
803 return Tmp.split('-').second; // Strip third component
806 StringRef Triple::getOSAndEnvironmentName() const {
807 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
808 return Tmp.split('-').second; // Strip second component
811 static unsigned EatNumber(StringRef &Str) {
812 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
816 // Consume the leading digit.
817 Result = Result*10 + (Str[0] - '0');
821 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
826 static void parseVersionFromName(StringRef Name, unsigned &Major,
827 unsigned &Minor, unsigned &Micro) {
828 // Any unset version defaults to 0.
829 Major = Minor = Micro = 0;
831 // Parse up to three components.
832 unsigned *Components[3] = {&Major, &Minor, &Micro};
833 for (unsigned i = 0; i != 3; ++i) {
834 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
837 // Consume the leading number.
838 *Components[i] = EatNumber(Name);
840 // Consume the separator, if present.
841 if (Name.startswith("."))
842 Name = Name.substr(1);
846 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
847 unsigned &Micro) const {
848 StringRef EnvironmentName = getEnvironmentName();
849 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
850 if (EnvironmentName.startswith(EnvironmentTypeName))
851 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
853 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
856 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
857 unsigned &Micro) const {
858 StringRef OSName = getOSName();
859 // Assume that the OS portion of the triple starts with the canonical name.
860 StringRef OSTypeName = getOSTypeName(getOS());
861 if (OSName.startswith(OSTypeName))
862 OSName = OSName.substr(OSTypeName.size());
864 parseVersionFromName(OSName, Major, Minor, Micro);
867 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
868 unsigned &Micro) const {
869 getOSVersion(Major, Minor, Micro);
872 default: llvm_unreachable("unexpected OS for Darwin triple");
874 // Default to darwin8, i.e., MacOSX 10.4.
877 // Darwin version numbers are skewed from OS X versions.
894 // Ignore the version from the triple. This is only handled because the
895 // the clang driver combines OS X and IOS support into a common Darwin
896 // toolchain that wants to know the OS X version number even when targeting
906 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
907 unsigned &Micro) const {
909 default: llvm_unreachable("unexpected OS for Darwin triple");
912 // Ignore the version from the triple. This is only handled because the
913 // the clang driver combines OS X and IOS support into a common Darwin
914 // toolchain that wants to know the iOS version number even when targeting
921 getOSVersion(Major, Minor, Micro);
922 // Default to 5.0 (or 7.0 for arm64).
924 Major = (getArch() == aarch64) ? 7 : 5;
929 void Triple::setTriple(const Twine &Str) {
933 void Triple::setArch(ArchType Kind) {
934 setArchName(getArchTypeName(Kind));
937 void Triple::setVendor(VendorType Kind) {
938 setVendorName(getVendorTypeName(Kind));
941 void Triple::setOS(OSType Kind) {
942 setOSName(getOSTypeName(Kind));
945 void Triple::setEnvironment(EnvironmentType Kind) {
946 if (ObjectFormat == getDefaultFormat(*this))
947 return setEnvironmentName(getEnvironmentTypeName(Kind));
949 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
950 getObjectFormatTypeName(ObjectFormat)).str());
953 void Triple::setObjectFormat(ObjectFormatType Kind) {
954 if (Environment == UnknownEnvironment)
955 return setEnvironmentName(getObjectFormatTypeName(Kind));
957 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
958 getObjectFormatTypeName(Kind)).str());
961 void Triple::setArchName(StringRef Str) {
962 // Work around a miscompilation bug for Twines in gcc 4.0.3.
963 SmallString<64> Triple;
966 Triple += getVendorName();
968 Triple += getOSAndEnvironmentName();
972 void Triple::setVendorName(StringRef Str) {
973 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
976 void Triple::setOSName(StringRef Str) {
977 if (hasEnvironment())
978 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
979 "-" + getEnvironmentName());
981 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
984 void Triple::setEnvironmentName(StringRef Str) {
985 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
989 void Triple::setOSAndEnvironmentName(StringRef Str) {
990 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
993 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
995 case llvm::Triple::UnknownArch:
998 case llvm::Triple::msp430:
1001 case llvm::Triple::arm:
1002 case llvm::Triple::armeb:
1003 case llvm::Triple::hexagon:
1004 case llvm::Triple::le32:
1005 case llvm::Triple::mips:
1006 case llvm::Triple::mipsel:
1007 case llvm::Triple::nvptx:
1008 case llvm::Triple::ppc:
1009 case llvm::Triple::r600:
1010 case llvm::Triple::sparc:
1011 case llvm::Triple::sparcel:
1012 case llvm::Triple::tce:
1013 case llvm::Triple::thumb:
1014 case llvm::Triple::thumbeb:
1015 case llvm::Triple::x86:
1016 case llvm::Triple::xcore:
1017 case llvm::Triple::amdil:
1018 case llvm::Triple::hsail:
1019 case llvm::Triple::spir:
1020 case llvm::Triple::kalimba:
1021 case llvm::Triple::shave:
1022 case llvm::Triple::wasm32:
1025 case llvm::Triple::aarch64:
1026 case llvm::Triple::aarch64_be:
1027 case llvm::Triple::amdgcn:
1028 case llvm::Triple::bpfel:
1029 case llvm::Triple::bpfeb:
1030 case llvm::Triple::le64:
1031 case llvm::Triple::mips64:
1032 case llvm::Triple::mips64el:
1033 case llvm::Triple::nvptx64:
1034 case llvm::Triple::ppc64:
1035 case llvm::Triple::ppc64le:
1036 case llvm::Triple::sparcv9:
1037 case llvm::Triple::systemz:
1038 case llvm::Triple::x86_64:
1039 case llvm::Triple::amdil64:
1040 case llvm::Triple::hsail64:
1041 case llvm::Triple::spir64:
1042 case llvm::Triple::wasm64:
1045 llvm_unreachable("Invalid architecture value");
1048 bool Triple::isArch64Bit() const {
1049 return getArchPointerBitWidth(getArch()) == 64;
1052 bool Triple::isArch32Bit() const {
1053 return getArchPointerBitWidth(getArch()) == 32;
1056 bool Triple::isArch16Bit() const {
1057 return getArchPointerBitWidth(getArch()) == 16;
1060 Triple Triple::get32BitArchVariant() const {
1062 switch (getArch()) {
1063 case Triple::UnknownArch:
1064 case Triple::aarch64:
1065 case Triple::aarch64_be:
1066 case Triple::amdgcn:
1069 case Triple::msp430:
1070 case Triple::systemz:
1071 case Triple::ppc64le:
1072 T.setArch(UnknownArch);
1080 case Triple::hexagon:
1081 case Triple::kalimba:
1084 case Triple::mipsel:
1089 case Triple::sparcel:
1092 case Triple::thumbeb:
1096 case Triple::wasm32:
1100 case Triple::le64: T.setArch(Triple::le32); break;
1101 case Triple::mips64: T.setArch(Triple::mips); break;
1102 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1103 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1104 case Triple::ppc64: T.setArch(Triple::ppc); break;
1105 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1106 case Triple::x86_64: T.setArch(Triple::x86); break;
1107 case Triple::amdil64: T.setArch(Triple::amdil); break;
1108 case Triple::hsail64: T.setArch(Triple::hsail); break;
1109 case Triple::spir64: T.setArch(Triple::spir); break;
1110 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1115 Triple Triple::get64BitArchVariant() const {
1117 switch (getArch()) {
1118 case Triple::UnknownArch:
1121 case Triple::hexagon:
1122 case Triple::kalimba:
1123 case Triple::msp430:
1127 case Triple::thumbeb:
1129 case Triple::sparcel:
1131 T.setArch(UnknownArch);
1134 case Triple::aarch64:
1135 case Triple::aarch64_be:
1139 case Triple::amdil64:
1140 case Triple::amdgcn:
1141 case Triple::hsail64:
1142 case Triple::spir64:
1143 case Triple::mips64:
1144 case Triple::mips64el:
1145 case Triple::nvptx64:
1147 case Triple::ppc64le:
1148 case Triple::sparcv9:
1149 case Triple::systemz:
1150 case Triple::x86_64:
1151 case Triple::wasm64:
1155 case Triple::le32: T.setArch(Triple::le64); break;
1156 case Triple::mips: T.setArch(Triple::mips64); break;
1157 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1158 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1159 case Triple::ppc: T.setArch(Triple::ppc64); break;
1160 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1161 case Triple::x86: T.setArch(Triple::x86_64); break;
1162 case Triple::amdil: T.setArch(Triple::amdil64); break;
1163 case Triple::hsail: T.setArch(Triple::hsail64); break;
1164 case Triple::spir: T.setArch(Triple::spir64); break;
1165 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1170 Triple Triple::getBigEndianArchVariant() const {
1172 switch (getArch()) {
1173 case Triple::UnknownArch:
1174 case Triple::amdgcn:
1175 case Triple::amdil64:
1177 case Triple::hexagon:
1178 case Triple::hsail64:
1180 case Triple::kalimba:
1183 case Triple::msp430:
1184 case Triple::nvptx64:
1188 case Triple::spir64:
1190 case Triple::wasm32:
1191 case Triple::wasm64:
1193 case Triple::x86_64:
1196 // ARM is intentionally unsupported here, changing the architecture would
1197 // drop any arch suffixes.
1200 T.setArch(UnknownArch);
1203 case Triple::aarch64_be:
1206 case Triple::mips64:
1211 case Triple::sparcv9:
1212 case Triple::systemz:
1214 case Triple::thumbeb:
1215 // Already big endian.
1218 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1219 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1220 case Triple::mips64el:T.setArch(Triple::mips64); break;
1221 case Triple::mipsel: T.setArch(Triple::mips); break;
1222 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1223 case Triple::sparcel: T.setArch(Triple::sparc); break;
1228 Triple Triple::getLittleEndianArchVariant() const {
1230 switch (getArch()) {
1231 case Triple::UnknownArch:
1233 case Triple::sparcv9:
1234 case Triple::systemz:
1237 // ARM is intentionally unsupported here, changing the architecture would
1238 // drop any arch suffixes.
1240 case Triple::thumbeb:
1241 T.setArch(UnknownArch);
1244 case Triple::aarch64:
1245 case Triple::amdgcn:
1246 case Triple::amdil64:
1250 case Triple::hexagon:
1251 case Triple::hsail64:
1253 case Triple::kalimba:
1256 case Triple::mips64el:
1257 case Triple::mipsel:
1258 case Triple::msp430:
1259 case Triple::nvptx64:
1261 case Triple::ppc64le:
1264 case Triple::sparcel:
1265 case Triple::spir64:
1268 case Triple::wasm32:
1269 case Triple::wasm64:
1271 case Triple::x86_64:
1273 // Already little endian.
1276 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1277 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1278 case Triple::mips64: T.setArch(Triple::mips64el); break;
1279 case Triple::mips: T.setArch(Triple::mipsel); break;
1280 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1281 case Triple::sparc: T.setArch(Triple::sparcel); break;
1286 const char *Triple::getARMCPUForArch(StringRef MArch) const {
1288 MArch = getArchName();
1289 MArch = ARMTargetParser::getCanonicalArchName(MArch);
1291 // Some defaults are forced.
1293 case llvm::Triple::FreeBSD:
1294 case llvm::Triple::NetBSD:
1295 if (!MArch.empty() && MArch == "v6")
1296 return "arm1176jzf-s";
1298 case llvm::Triple::Win32:
1299 // FIXME: this is invalid for WindowsCE
1308 const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
1312 // If no specific architecture version is requested, return the minimum CPU
1313 // required by the OS and environment.
1315 case llvm::Triple::NetBSD:
1316 switch (getEnvironment()) {
1317 case llvm::Triple::GNUEABIHF:
1318 case llvm::Triple::GNUEABI:
1319 case llvm::Triple::EABIHF:
1320 case llvm::Triple::EABI:
1321 return "arm926ej-s";
1325 case llvm::Triple::NaCl:
1328 switch (getEnvironment()) {
1329 case llvm::Triple::EABIHF:
1330 case llvm::Triple::GNUEABIHF:
1331 return "arm1176jzf-s";
1337 llvm_unreachable("invalid arch name");