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";
65 llvm_unreachable("Invalid ArchType!");
68 const char *Triple::getArchTypePrefix(ArchType Kind) {
74 case aarch64_be: return "aarch64";
79 case thumbeb: return "arm";
83 case ppc: return "ppc";
88 case mips64el: return "mips";
90 case hexagon: return "hexagon";
93 case r600: return "amdgpu";
96 case bpfeb: return "bpf";
100 case sparc: return "sparc";
102 case systemz: return "s390";
105 case x86_64: return "x86";
107 case xcore: return "xcore";
109 case nvptx: return "nvptx";
110 case nvptx64: return "nvptx";
112 case le32: return "le32";
113 case le64: return "le64";
116 case amdil64: return "amdil";
119 case hsail64: return "hsail";
122 case spir64: return "spir";
123 case kalimba: return "kalimba";
124 case shave: return "shave";
128 const char *Triple::getVendorTypeName(VendorType Kind) {
130 case UnknownVendor: return "unknown";
132 case Apple: return "apple";
133 case PC: return "pc";
134 case SCEI: return "scei";
135 case BGP: return "bgp";
136 case BGQ: return "bgq";
137 case Freescale: return "fsl";
138 case IBM: return "ibm";
139 case ImaginationTechnologies: return "img";
140 case MipsTechnologies: return "mti";
141 case NVIDIA: return "nvidia";
142 case CSR: return "csr";
145 llvm_unreachable("Invalid VendorType!");
148 const char *Triple::getOSTypeName(OSType Kind) {
150 case UnknownOS: return "unknown";
152 case CloudABI: return "cloudabi";
153 case Darwin: return "darwin";
154 case DragonFly: return "dragonfly";
155 case FreeBSD: return "freebsd";
156 case IOS: return "ios";
157 case KFreeBSD: return "kfreebsd";
158 case Linux: return "linux";
159 case Lv2: return "lv2";
160 case MacOSX: return "macosx";
161 case NetBSD: return "netbsd";
162 case OpenBSD: return "openbsd";
163 case Solaris: return "solaris";
164 case Win32: return "windows";
165 case Haiku: return "haiku";
166 case Minix: return "minix";
167 case RTEMS: return "rtems";
168 case NaCl: return "nacl";
169 case CNK: return "cnk";
170 case Bitrig: return "bitrig";
171 case AIX: return "aix";
172 case CUDA: return "cuda";
173 case NVCL: return "nvcl";
174 case AMDHSA: return "amdhsa";
175 case PS4: return "ps4";
178 llvm_unreachable("Invalid OSType");
181 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
183 case UnknownEnvironment: return "unknown";
184 case GNU: return "gnu";
185 case GNUEABIHF: return "gnueabihf";
186 case GNUEABI: return "gnueabi";
187 case GNUX32: return "gnux32";
188 case CODE16: return "code16";
189 case EABI: return "eabi";
190 case EABIHF: return "eabihf";
191 case Android: return "android";
192 case MSVC: return "msvc";
193 case Itanium: return "itanium";
194 case Cygnus: return "cygnus";
197 llvm_unreachable("Invalid EnvironmentType!");
200 static Triple::ArchType parseBPFArch(StringRef ArchName) {
201 if (ArchName.equals("bpf")) {
202 if (sys::IsLittleEndianHost)
203 return Triple::bpfel;
205 return Triple::bpfeb;
206 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
207 return Triple::bpfeb;
208 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
209 return Triple::bpfel;
211 return Triple::UnknownArch;
215 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
216 Triple::ArchType BPFArch(parseBPFArch(Name));
217 return StringSwitch<Triple::ArchType>(Name)
218 .Case("aarch64", aarch64)
219 .Case("aarch64_be", aarch64_be)
220 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
222 .Case("armeb", armeb)
223 .StartsWith("bpf", BPFArch)
225 .Case("mipsel", mipsel)
226 .Case("mips64", mips64)
227 .Case("mips64el", mips64el)
228 .Case("msp430", msp430)
229 .Case("ppc64", ppc64)
232 .Case("ppc64le", ppc64le)
234 .Case("amdgcn", amdgcn)
235 .Case("hexagon", hexagon)
236 .Case("sparc", sparc)
237 .Case("sparcel", sparcel)
238 .Case("sparcv9", sparcv9)
239 .Case("systemz", systemz)
241 .Case("thumb", thumb)
242 .Case("thumbeb", thumbeb)
244 .Case("x86-64", x86_64)
245 .Case("xcore", xcore)
246 .Case("nvptx", nvptx)
247 .Case("nvptx64", nvptx64)
250 .Case("amdil", amdil)
251 .Case("amdil64", amdil64)
252 .Case("hsail", hsail)
253 .Case("hsail64", hsail64)
255 .Case("spir64", spir64)
256 .Case("kalimba", kalimba)
257 .Case("shave", shave)
258 .Default(UnknownArch);
261 static Triple::ArchType parseARMArch(StringRef ArchName) {
262 unsigned ISA = ARMTargetParser::parseArchISA(ArchName);
263 unsigned ENDIAN = ARMTargetParser::parseArchEndian(ArchName);
265 Triple::ArchType arch = Triple::UnknownArch;
267 case ARM::EK_LITTLE: {
273 arch = Triple::thumb;
275 case ARM::IK_AARCH64:
276 arch = Triple::aarch64;
284 arch = Triple::armeb;
287 arch = Triple::thumbeb;
289 case ARM::IK_AARCH64:
290 arch = Triple::aarch64_be;
297 ArchName = ARMTargetParser::getCanonicalArchName(ArchName);
298 if (ArchName.empty())
299 return Triple::UnknownArch;
301 // Thumb only exists in v4+
302 if (ISA == ARM::IK_THUMB &&
303 (ArchName.startswith("v2") || ArchName.startswith("v3")))
304 return Triple::UnknownArch;
306 // Thumb only for v6m
307 unsigned Profile = ARMTargetParser::parseArchProfile(ArchName);
308 unsigned Version = ARMTargetParser::parseArchVersion(ArchName);
309 if (Profile == ARM::PK_M && Version == 6) {
310 if (ENDIAN == ARM::EK_BIG)
311 return Triple::thumbeb;
313 return Triple::thumb;
319 static Triple::ArchType parseArch(StringRef ArchName) {
320 Triple::ArchType ARMArch(parseARMArch(ArchName));
321 Triple::ArchType BPFArch(parseBPFArch(ArchName));
323 return StringSwitch<Triple::ArchType>(ArchName)
324 .Cases("i386", "i486", "i586", "i686", Triple::x86)
325 // FIXME: Do we need to support these?
326 .Cases("i786", "i886", "i986", Triple::x86)
327 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
328 .Case("powerpc", Triple::ppc)
329 .Cases("powerpc64", "ppu", Triple::ppc64)
330 .Case("powerpc64le", Triple::ppc64le)
331 .Case("xscale", Triple::arm)
332 .Case("xscaleeb", Triple::armeb)
333 .StartsWith("arm", ARMArch)
334 .StartsWith("thumb", ARMArch)
335 .StartsWith("aarch64", ARMArch)
336 .Case("msp430", Triple::msp430)
337 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
338 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
339 .Cases("mips64", "mips64eb", Triple::mips64)
340 .Case("mips64el", Triple::mips64el)
341 .Case("r600", Triple::r600)
342 .Case("amdgcn", Triple::amdgcn)
343 .StartsWith("bpf", BPFArch)
344 .Case("hexagon", Triple::hexagon)
345 .Case("s390x", Triple::systemz)
346 .Case("sparc", Triple::sparc)
347 .Case("sparcel", Triple::sparcel)
348 .Cases("sparcv9", "sparc64", Triple::sparcv9)
349 .Case("tce", Triple::tce)
350 .Case("xcore", Triple::xcore)
351 .Case("nvptx", Triple::nvptx)
352 .Case("nvptx64", Triple::nvptx64)
353 .Case("le32", Triple::le32)
354 .Case("le64", Triple::le64)
355 .Case("amdil", Triple::amdil)
356 .Case("amdil64", Triple::amdil64)
357 .Case("hsail", Triple::hsail)
358 .Case("hsail64", Triple::hsail64)
359 .Case("spir", Triple::spir)
360 .Case("spir64", Triple::spir64)
361 .StartsWith("kalimba", Triple::kalimba)
362 .Case("shave", Triple::shave)
363 .Default(Triple::UnknownArch);
366 static Triple::VendorType parseVendor(StringRef VendorName) {
367 return StringSwitch<Triple::VendorType>(VendorName)
368 .Case("apple", Triple::Apple)
369 .Case("pc", Triple::PC)
370 .Case("scei", Triple::SCEI)
371 .Case("bgp", Triple::BGP)
372 .Case("bgq", Triple::BGQ)
373 .Case("fsl", Triple::Freescale)
374 .Case("ibm", Triple::IBM)
375 .Case("img", Triple::ImaginationTechnologies)
376 .Case("mti", Triple::MipsTechnologies)
377 .Case("nvidia", Triple::NVIDIA)
378 .Case("csr", Triple::CSR)
379 .Default(Triple::UnknownVendor);
382 static Triple::OSType parseOS(StringRef OSName) {
383 return StringSwitch<Triple::OSType>(OSName)
384 .StartsWith("cloudabi", Triple::CloudABI)
385 .StartsWith("darwin", Triple::Darwin)
386 .StartsWith("dragonfly", Triple::DragonFly)
387 .StartsWith("freebsd", Triple::FreeBSD)
388 .StartsWith("ios", Triple::IOS)
389 .StartsWith("kfreebsd", Triple::KFreeBSD)
390 .StartsWith("linux", Triple::Linux)
391 .StartsWith("lv2", Triple::Lv2)
392 .StartsWith("macosx", Triple::MacOSX)
393 .StartsWith("netbsd", Triple::NetBSD)
394 .StartsWith("openbsd", Triple::OpenBSD)
395 .StartsWith("solaris", Triple::Solaris)
396 .StartsWith("win32", Triple::Win32)
397 .StartsWith("windows", Triple::Win32)
398 .StartsWith("haiku", Triple::Haiku)
399 .StartsWith("minix", Triple::Minix)
400 .StartsWith("rtems", Triple::RTEMS)
401 .StartsWith("nacl", Triple::NaCl)
402 .StartsWith("cnk", Triple::CNK)
403 .StartsWith("bitrig", Triple::Bitrig)
404 .StartsWith("aix", Triple::AIX)
405 .StartsWith("cuda", Triple::CUDA)
406 .StartsWith("nvcl", Triple::NVCL)
407 .StartsWith("amdhsa", Triple::AMDHSA)
408 .StartsWith("ps4", Triple::PS4)
409 .Default(Triple::UnknownOS);
412 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
413 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
414 .StartsWith("eabihf", Triple::EABIHF)
415 .StartsWith("eabi", Triple::EABI)
416 .StartsWith("gnueabihf", Triple::GNUEABIHF)
417 .StartsWith("gnueabi", Triple::GNUEABI)
418 .StartsWith("gnux32", Triple::GNUX32)
419 .StartsWith("code16", Triple::CODE16)
420 .StartsWith("gnu", Triple::GNU)
421 .StartsWith("android", Triple::Android)
422 .StartsWith("msvc", Triple::MSVC)
423 .StartsWith("itanium", Triple::Itanium)
424 .StartsWith("cygnus", Triple::Cygnus)
425 .Default(Triple::UnknownEnvironment);
428 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
429 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
430 .EndsWith("coff", Triple::COFF)
431 .EndsWith("elf", Triple::ELF)
432 .EndsWith("macho", Triple::MachO)
433 .Default(Triple::UnknownObjectFormat);
436 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
437 StringRef ARMSubArch = ARMTargetParser::getCanonicalArchName(SubArchName);
439 // For now, this is the small part. Early return.
440 if (ARMSubArch.empty())
441 return StringSwitch<Triple::SubArchType>(SubArchName)
442 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
443 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
444 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
445 .Default(Triple::NoSubArch);
448 switch(ARMTargetParser::parseArch(ARMSubArch)) {
450 return Triple::NoSubArch;
452 return Triple::ARMSubArch_v4t;
456 return Triple::ARMSubArch_v5;
457 case ARM::AK_ARMV5TE:
459 case ARM::AK_IWMMXT2:
461 case ARM::AK_ARMV5TEJ:
462 return Triple::ARMSubArch_v5te;
466 return Triple::ARMSubArch_v6;
468 case ARM::AK_ARMV6ZK:
469 case ARM::AK_ARMV6HL:
470 return Triple::ARMSubArch_v6k;
471 case ARM::AK_ARMV6T2:
472 return Triple::ARMSubArch_v6t2;
474 case ARM::AK_ARMV6SM:
475 return Triple::ARMSubArch_v6m;
480 case ARM::AK_ARMV7HL:
481 return Triple::ARMSubArch_v7;
483 return Triple::ARMSubArch_v7m;
485 return Triple::ARMSubArch_v7s;
486 case ARM::AK_ARMV7EM:
487 return Triple::ARMSubArch_v7em;
489 return Triple::ARMSubArch_v8;
490 case ARM::AK_ARMV8_1A:
491 return Triple::ARMSubArch_v8_1a;
493 return Triple::NoSubArch;
497 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
499 case Triple::UnknownObjectFormat: return "";
500 case Triple::COFF: return "coff";
501 case Triple::ELF: return "elf";
502 case Triple::MachO: return "macho";
504 llvm_unreachable("unknown object format type");
507 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
508 switch (T.getArch()) {
511 case Triple::hexagon:
515 case Triple::mips64el:
519 case Triple::sparcv9:
520 case Triple::systemz:
522 case Triple::ppc64le:
528 return Triple::MachO;
533 return Triple::MachO;
534 else if (T.isOSWindows())
539 /// \brief Construct a triple from the string representation provided.
541 /// This stores the string representation and parses the various pieces into
543 Triple::Triple(const Twine &Str)
545 Arch(parseArch(getArchName())),
546 SubArch(parseSubArch(getArchName())),
547 Vendor(parseVendor(getVendorName())),
548 OS(parseOS(getOSName())),
549 Environment(parseEnvironment(getEnvironmentName())),
550 ObjectFormat(parseFormat(getEnvironmentName())) {
551 if (ObjectFormat == Triple::UnknownObjectFormat)
552 ObjectFormat = getDefaultFormat(*this);
555 /// \brief Construct a triple from string representations of the architecture,
558 /// This joins each argument into a canonical string representation and parses
559 /// them into enum members. It leaves the environment unknown and omits it from
560 /// the string representation.
561 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
562 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
563 Arch(parseArch(ArchStr.str())),
564 SubArch(parseSubArch(ArchStr.str())),
565 Vendor(parseVendor(VendorStr.str())),
566 OS(parseOS(OSStr.str())),
567 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
568 ObjectFormat = getDefaultFormat(*this);
571 /// \brief Construct a triple from string representations of the architecture,
572 /// vendor, OS, and environment.
574 /// This joins each argument into a canonical string representation and parses
575 /// them into enum members.
576 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
577 const Twine &EnvironmentStr)
578 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
579 EnvironmentStr).str()),
580 Arch(parseArch(ArchStr.str())),
581 SubArch(parseSubArch(ArchStr.str())),
582 Vendor(parseVendor(VendorStr.str())),
583 OS(parseOS(OSStr.str())),
584 Environment(parseEnvironment(EnvironmentStr.str())),
585 ObjectFormat(parseFormat(EnvironmentStr.str())) {
586 if (ObjectFormat == Triple::UnknownObjectFormat)
587 ObjectFormat = getDefaultFormat(*this);
590 std::string Triple::normalize(StringRef Str) {
591 bool IsMinGW32 = false;
592 bool IsCygwin = false;
594 // Parse into components.
595 SmallVector<StringRef, 4> Components;
596 Str.split(Components, "-");
598 // If the first component corresponds to a known architecture, preferentially
599 // use it for the architecture. If the second component corresponds to a
600 // known vendor, preferentially use it for the vendor, etc. This avoids silly
601 // component movement when a component parses as (eg) both a valid arch and a
603 ArchType Arch = UnknownArch;
604 if (Components.size() > 0)
605 Arch = parseArch(Components[0]);
606 VendorType Vendor = UnknownVendor;
607 if (Components.size() > 1)
608 Vendor = parseVendor(Components[1]);
609 OSType OS = UnknownOS;
610 if (Components.size() > 2) {
611 OS = parseOS(Components[2]);
612 IsCygwin = Components[2].startswith("cygwin");
613 IsMinGW32 = Components[2].startswith("mingw");
615 EnvironmentType Environment = UnknownEnvironment;
616 if (Components.size() > 3)
617 Environment = parseEnvironment(Components[3]);
618 ObjectFormatType ObjectFormat = UnknownObjectFormat;
619 if (Components.size() > 4)
620 ObjectFormat = parseFormat(Components[4]);
622 // Note which components are already in their final position. These will not
625 Found[0] = Arch != UnknownArch;
626 Found[1] = Vendor != UnknownVendor;
627 Found[2] = OS != UnknownOS;
628 Found[3] = Environment != UnknownEnvironment;
630 // If they are not there already, permute the components into their canonical
631 // positions by seeing if they parse as a valid architecture, and if so moving
632 // the component to the architecture position etc.
633 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
635 continue; // Already in the canonical position.
637 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
638 // Do not reparse any components that already matched.
639 if (Idx < array_lengthof(Found) && Found[Idx])
642 // Does this component parse as valid for the target position?
644 StringRef Comp = Components[Idx];
646 default: llvm_unreachable("unexpected component type!");
648 Arch = parseArch(Comp);
649 Valid = Arch != UnknownArch;
652 Vendor = parseVendor(Comp);
653 Valid = Vendor != UnknownVendor;
657 IsCygwin = Comp.startswith("cygwin");
658 IsMinGW32 = Comp.startswith("mingw");
659 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
662 Environment = parseEnvironment(Comp);
663 Valid = Environment != UnknownEnvironment;
665 ObjectFormat = parseFormat(Comp);
666 Valid = ObjectFormat != UnknownObjectFormat;
671 continue; // Nope, try the next component.
673 // Move the component to the target position, pushing any non-fixed
674 // components that are in the way to the right. This tends to give
675 // good results in the common cases of a forgotten vendor component
676 // or a wrongly positioned environment.
678 // Insert left, pushing the existing components to the right. For
679 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
680 StringRef CurrentComponent(""); // The empty component.
681 // Replace the component we are moving with an empty component.
682 std::swap(CurrentComponent, Components[Idx]);
683 // Insert the component being moved at Pos, displacing any existing
684 // components to the right.
685 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
686 // Skip over any fixed components.
687 while (i < array_lengthof(Found) && Found[i])
689 // Place the component at the new position, getting the component
690 // that was at this position - it will be moved right.
691 std::swap(CurrentComponent, Components[i]);
693 } else if (Pos > Idx) {
694 // Push right by inserting empty components until the component at Idx
695 // reaches the target position Pos. For example, pc-a -> -pc-a when
696 // moving pc to the second position.
698 // Insert one empty component at Idx.
699 StringRef CurrentComponent(""); // The empty component.
700 for (unsigned i = Idx; i < Components.size();) {
701 // Place the component at the new position, getting the component
702 // that was at this position - it will be moved right.
703 std::swap(CurrentComponent, Components[i]);
704 // If it was placed on top of an empty component then we are done.
705 if (CurrentComponent.empty())
707 // Advance to the next component, skipping any fixed components.
708 while (++i < array_lengthof(Found) && Found[i])
711 // The last component was pushed off the end - append it.
712 if (!CurrentComponent.empty())
713 Components.push_back(CurrentComponent);
715 // Advance Idx to the component's new position.
716 while (++Idx < array_lengthof(Found) && Found[Idx])
718 } while (Idx < Pos); // Add more until the final position is reached.
720 assert(Pos < Components.size() && Components[Pos] == Comp &&
721 "Component moved wrong!");
727 // Special case logic goes here. At this point Arch, Vendor and OS have the
728 // correct values for the computed components.
729 std::string NormalizedEnvironment;
730 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
731 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
732 if (AndroidVersion.empty()) {
733 Components[3] = "android";
735 NormalizedEnvironment = Twine("android", AndroidVersion).str();
736 Components[3] = NormalizedEnvironment;
740 if (OS == Triple::Win32) {
741 Components.resize(4);
742 Components[2] = "windows";
743 if (Environment == UnknownEnvironment) {
744 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
745 Components[3] = "msvc";
747 Components[3] = getObjectFormatTypeName(ObjectFormat);
749 } else if (IsMinGW32) {
750 Components.resize(4);
751 Components[2] = "windows";
752 Components[3] = "gnu";
753 } else if (IsCygwin) {
754 Components.resize(4);
755 Components[2] = "windows";
756 Components[3] = "cygnus";
758 if (IsMinGW32 || IsCygwin ||
759 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
760 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
761 Components.resize(5);
762 Components[4] = getObjectFormatTypeName(ObjectFormat);
766 // Stick the corrected components back together to form the normalized string.
767 std::string Normalized;
768 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
769 if (i) Normalized += '-';
770 Normalized += Components[i];
775 StringRef Triple::getArchName() const {
776 return StringRef(Data).split('-').first; // Isolate first component
779 StringRef Triple::getVendorName() const {
780 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
781 return Tmp.split('-').first; // Isolate second component
784 StringRef Triple::getOSName() const {
785 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
786 Tmp = Tmp.split('-').second; // Strip second component
787 return Tmp.split('-').first; // Isolate third component
790 StringRef Triple::getEnvironmentName() const {
791 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
792 Tmp = Tmp.split('-').second; // Strip second component
793 return Tmp.split('-').second; // Strip third component
796 StringRef Triple::getOSAndEnvironmentName() const {
797 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
798 return Tmp.split('-').second; // Strip second component
801 static unsigned EatNumber(StringRef &Str) {
802 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
806 // Consume the leading digit.
807 Result = Result*10 + (Str[0] - '0');
811 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
816 static void parseVersionFromName(StringRef Name, unsigned &Major,
817 unsigned &Minor, unsigned &Micro) {
818 // Any unset version defaults to 0.
819 Major = Minor = Micro = 0;
821 // Parse up to three components.
822 unsigned *Components[3] = {&Major, &Minor, &Micro};
823 for (unsigned i = 0; i != 3; ++i) {
824 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
827 // Consume the leading number.
828 *Components[i] = EatNumber(Name);
830 // Consume the separator, if present.
831 if (Name.startswith("."))
832 Name = Name.substr(1);
836 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
837 unsigned &Micro) const {
838 StringRef EnvironmentName = getEnvironmentName();
839 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
840 if (EnvironmentName.startswith(EnvironmentTypeName))
841 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
843 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
846 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
847 unsigned &Micro) const {
848 StringRef OSName = getOSName();
849 // Assume that the OS portion of the triple starts with the canonical name.
850 StringRef OSTypeName = getOSTypeName(getOS());
851 if (OSName.startswith(OSTypeName))
852 OSName = OSName.substr(OSTypeName.size());
854 parseVersionFromName(OSName, Major, Minor, Micro);
857 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
858 unsigned &Micro) const {
859 getOSVersion(Major, Minor, Micro);
862 default: llvm_unreachable("unexpected OS for Darwin triple");
864 // Default to darwin8, i.e., MacOSX 10.4.
867 // Darwin version numbers are skewed from OS X versions.
884 // Ignore the version from the triple. This is only handled because the
885 // the clang driver combines OS X and IOS support into a common Darwin
886 // toolchain that wants to know the OS X version number even when targeting
896 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
897 unsigned &Micro) const {
899 default: llvm_unreachable("unexpected OS for Darwin triple");
902 // Ignore the version from the triple. This is only handled because the
903 // the clang driver combines OS X and IOS support into a common Darwin
904 // toolchain that wants to know the iOS version number even when targeting
911 getOSVersion(Major, Minor, Micro);
912 // Default to 5.0 (or 7.0 for arm64).
914 Major = (getArch() == aarch64) ? 7 : 5;
919 void Triple::setTriple(const Twine &Str) {
923 void Triple::setArch(ArchType Kind) {
924 setArchName(getArchTypeName(Kind));
927 void Triple::setVendor(VendorType Kind) {
928 setVendorName(getVendorTypeName(Kind));
931 void Triple::setOS(OSType Kind) {
932 setOSName(getOSTypeName(Kind));
935 void Triple::setEnvironment(EnvironmentType Kind) {
936 if (ObjectFormat == getDefaultFormat(*this))
937 return setEnvironmentName(getEnvironmentTypeName(Kind));
939 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
940 getObjectFormatTypeName(ObjectFormat)).str());
943 void Triple::setObjectFormat(ObjectFormatType Kind) {
944 if (Environment == UnknownEnvironment)
945 return setEnvironmentName(getObjectFormatTypeName(Kind));
947 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
948 getObjectFormatTypeName(Kind)).str());
951 void Triple::setArchName(StringRef Str) {
952 // Work around a miscompilation bug for Twines in gcc 4.0.3.
953 SmallString<64> Triple;
956 Triple += getVendorName();
958 Triple += getOSAndEnvironmentName();
962 void Triple::setVendorName(StringRef Str) {
963 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
966 void Triple::setOSName(StringRef Str) {
967 if (hasEnvironment())
968 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
969 "-" + getEnvironmentName());
971 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
974 void Triple::setEnvironmentName(StringRef Str) {
975 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
979 void Triple::setOSAndEnvironmentName(StringRef Str) {
980 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
983 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
985 case llvm::Triple::UnknownArch:
988 case llvm::Triple::msp430:
991 case llvm::Triple::arm:
992 case llvm::Triple::armeb:
993 case llvm::Triple::hexagon:
994 case llvm::Triple::le32:
995 case llvm::Triple::mips:
996 case llvm::Triple::mipsel:
997 case llvm::Triple::nvptx:
998 case llvm::Triple::ppc:
999 case llvm::Triple::r600:
1000 case llvm::Triple::sparc:
1001 case llvm::Triple::sparcel:
1002 case llvm::Triple::tce:
1003 case llvm::Triple::thumb:
1004 case llvm::Triple::thumbeb:
1005 case llvm::Triple::x86:
1006 case llvm::Triple::xcore:
1007 case llvm::Triple::amdil:
1008 case llvm::Triple::hsail:
1009 case llvm::Triple::spir:
1010 case llvm::Triple::kalimba:
1011 case llvm::Triple::shave:
1014 case llvm::Triple::aarch64:
1015 case llvm::Triple::aarch64_be:
1016 case llvm::Triple::amdgcn:
1017 case llvm::Triple::bpfel:
1018 case llvm::Triple::bpfeb:
1019 case llvm::Triple::le64:
1020 case llvm::Triple::mips64:
1021 case llvm::Triple::mips64el:
1022 case llvm::Triple::nvptx64:
1023 case llvm::Triple::ppc64:
1024 case llvm::Triple::ppc64le:
1025 case llvm::Triple::sparcv9:
1026 case llvm::Triple::systemz:
1027 case llvm::Triple::x86_64:
1028 case llvm::Triple::amdil64:
1029 case llvm::Triple::hsail64:
1030 case llvm::Triple::spir64:
1033 llvm_unreachable("Invalid architecture value");
1036 bool Triple::isArch64Bit() const {
1037 return getArchPointerBitWidth(getArch()) == 64;
1040 bool Triple::isArch32Bit() const {
1041 return getArchPointerBitWidth(getArch()) == 32;
1044 bool Triple::isArch16Bit() const {
1045 return getArchPointerBitWidth(getArch()) == 16;
1048 Triple Triple::get32BitArchVariant() const {
1050 switch (getArch()) {
1051 case Triple::UnknownArch:
1052 case Triple::aarch64:
1053 case Triple::aarch64_be:
1054 case Triple::amdgcn:
1057 case Triple::msp430:
1058 case Triple::systemz:
1059 case Triple::ppc64le:
1060 T.setArch(UnknownArch);
1068 case Triple::hexagon:
1069 case Triple::kalimba:
1072 case Triple::mipsel:
1077 case Triple::sparcel:
1080 case Triple::thumbeb:
1087 case Triple::le64: T.setArch(Triple::le32); break;
1088 case Triple::mips64: T.setArch(Triple::mips); break;
1089 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1090 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1091 case Triple::ppc64: T.setArch(Triple::ppc); break;
1092 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1093 case Triple::x86_64: T.setArch(Triple::x86); break;
1094 case Triple::amdil64: T.setArch(Triple::amdil); break;
1095 case Triple::hsail64: T.setArch(Triple::hsail); break;
1096 case Triple::spir64: T.setArch(Triple::spir); break;
1101 Triple Triple::get64BitArchVariant() const {
1103 switch (getArch()) {
1104 case Triple::UnknownArch:
1107 case Triple::hexagon:
1108 case Triple::kalimba:
1109 case Triple::msp430:
1113 case Triple::thumbeb:
1115 case Triple::sparcel:
1117 T.setArch(UnknownArch);
1120 case Triple::aarch64:
1121 case Triple::aarch64_be:
1125 case Triple::amdil64:
1126 case Triple::amdgcn:
1127 case Triple::hsail64:
1128 case Triple::spir64:
1129 case Triple::mips64:
1130 case Triple::mips64el:
1131 case Triple::nvptx64:
1133 case Triple::ppc64le:
1134 case Triple::sparcv9:
1135 case Triple::systemz:
1136 case Triple::x86_64:
1140 case Triple::le32: T.setArch(Triple::le64); break;
1141 case Triple::mips: T.setArch(Triple::mips64); break;
1142 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1143 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1144 case Triple::ppc: T.setArch(Triple::ppc64); break;
1145 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1146 case Triple::x86: T.setArch(Triple::x86_64); break;
1147 case Triple::amdil: T.setArch(Triple::amdil64); break;
1148 case Triple::hsail: T.setArch(Triple::hsail64); break;
1149 case Triple::spir: T.setArch(Triple::spir64); break;
1154 const char *Triple::getARMCPUForArch(StringRef MArch) const {
1156 MArch = getArchName();
1157 MArch = ARMTargetParser::getCanonicalArchName(MArch);
1159 // Some defaults are forced.
1161 case llvm::Triple::FreeBSD:
1162 case llvm::Triple::NetBSD:
1163 if (!MArch.empty() && MArch == "v6")
1164 return "arm1176jzf-s";
1166 case llvm::Triple::Win32:
1167 // FIXME: this is invalid for WindowsCE
1176 const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
1180 // If no specific architecture version is requested, return the minimum CPU
1181 // required by the OS and environment.
1183 case llvm::Triple::NetBSD:
1184 switch (getEnvironment()) {
1185 case llvm::Triple::GNUEABIHF:
1186 case llvm::Triple::GNUEABI:
1187 case llvm::Triple::EABIHF:
1188 case llvm::Triple::EABI:
1189 return "arm926ej-s";
1193 case llvm::Triple::NaCl:
1196 switch (getEnvironment()) {
1197 case llvm::Triple::EABIHF:
1198 case llvm::Triple::GNUEABIHF:
1199 return "arm1176jzf-s";
1205 llvm_unreachable("invalid arch name");