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"
19 const char *Triple::getArchTypeName(ArchType Kind) {
21 case UnknownArch: return "unknown";
23 case aarch64: return "aarch64";
24 case aarch64_be: return "aarch64_be";
25 case arm: return "arm";
26 case armeb: return "armeb";
27 case bpf: return "bpf";
28 case hexagon: return "hexagon";
29 case mips: return "mips";
30 case mipsel: return "mipsel";
31 case mips64: return "mips64";
32 case mips64el: return "mips64el";
33 case msp430: return "msp430";
34 case ppc64: return "powerpc64";
35 case ppc64le: return "powerpc64le";
36 case ppc: return "powerpc";
37 case r600: return "r600";
38 case amdgcn: return "amdgcn";
39 case sparc: return "sparc";
40 case sparcv9: return "sparcv9";
41 case sparcel: return "sparcel";
42 case systemz: return "s390x";
43 case tce: return "tce";
44 case thumb: return "thumb";
45 case thumbeb: return "thumbeb";
46 case x86: return "i386";
47 case x86_64: return "x86_64";
48 case xcore: return "xcore";
49 case nvptx: return "nvptx";
50 case nvptx64: return "nvptx64";
51 case le32: return "le32";
52 case le64: return "le64";
53 case amdil: return "amdil";
54 case amdil64: return "amdil64";
55 case hsail: return "hsail";
56 case hsail64: return "hsail64";
57 case spir: return "spir";
58 case spir64: return "spir64";
59 case kalimba: return "kalimba";
62 llvm_unreachable("Invalid ArchType!");
65 const char *Triple::getArchTypePrefix(ArchType Kind) {
71 case aarch64_be: return "aarch64";
76 case thumbeb: return "arm";
80 case ppc: return "ppc";
85 case mips64el: return "mips";
87 case hexagon: return "hexagon";
90 case r600: return "amdgpu";
92 case bpf: return "bpf";
96 case sparc: return "sparc";
98 case systemz: return "s390";
101 case x86_64: return "x86";
103 case xcore: return "xcore";
105 case nvptx: return "nvptx";
106 case nvptx64: return "nvptx";
108 case le32: return "le32";
109 case le64: return "le64";
112 case amdil64: return "amdil";
115 case hsail64: return "hsail";
118 case spir64: return "spir";
119 case kalimba: return "kalimba";
123 const char *Triple::getVendorTypeName(VendorType Kind) {
125 case UnknownVendor: return "unknown";
127 case Apple: return "apple";
128 case PC: return "pc";
129 case SCEI: return "scei";
130 case BGP: return "bgp";
131 case BGQ: return "bgq";
132 case Freescale: return "fsl";
133 case IBM: return "ibm";
134 case ImaginationTechnologies: return "img";
135 case MipsTechnologies: return "mti";
136 case NVIDIA: return "nvidia";
137 case CSR: return "csr";
140 llvm_unreachable("Invalid VendorType!");
143 const char *Triple::getOSTypeName(OSType Kind) {
145 case UnknownOS: return "unknown";
147 case CloudABI: return "cloudabi";
148 case Darwin: return "darwin";
149 case DragonFly: return "dragonfly";
150 case FreeBSD: return "freebsd";
151 case IOS: return "ios";
152 case KFreeBSD: return "kfreebsd";
153 case Linux: return "linux";
154 case Lv2: return "lv2";
155 case MacOSX: return "macosx";
156 case NetBSD: return "netbsd";
157 case OpenBSD: return "openbsd";
158 case Solaris: return "solaris";
159 case Win32: return "windows";
160 case Haiku: return "haiku";
161 case Minix: return "minix";
162 case RTEMS: return "rtems";
163 case NaCl: return "nacl";
164 case CNK: return "cnk";
165 case Bitrig: return "bitrig";
166 case AIX: return "aix";
167 case CUDA: return "cuda";
168 case NVCL: return "nvcl";
169 case AMDHSA: return "amdhsa";
170 case PS4: return "ps4";
173 llvm_unreachable("Invalid OSType");
176 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
178 case UnknownEnvironment: return "unknown";
179 case GNU: return "gnu";
180 case GNUEABIHF: return "gnueabihf";
181 case GNUEABI: return "gnueabi";
182 case GNUX32: return "gnux32";
183 case CODE16: return "code16";
184 case EABI: return "eabi";
185 case EABIHF: return "eabihf";
186 case Android: return "android";
187 case MSVC: return "msvc";
188 case Itanium: return "itanium";
189 case Cygnus: return "cygnus";
192 llvm_unreachable("Invalid EnvironmentType!");
195 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
196 return StringSwitch<Triple::ArchType>(Name)
197 .Case("aarch64", aarch64)
198 .Case("aarch64_be", aarch64_be)
199 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
201 .Case("armeb", armeb)
204 .Case("mipsel", mipsel)
205 .Case("mips64", mips64)
206 .Case("mips64el", mips64el)
207 .Case("msp430", msp430)
208 .Case("ppc64", ppc64)
211 .Case("ppc64le", ppc64le)
213 .Case("amdgcn", amdgcn)
214 .Case("hexagon", hexagon)
215 .Case("sparc", sparc)
216 .Case("sparcel", sparcel)
217 .Case("sparcv9", sparcv9)
218 .Case("systemz", systemz)
220 .Case("thumb", thumb)
221 .Case("thumbeb", thumbeb)
223 .Case("x86-64", x86_64)
224 .Case("xcore", xcore)
225 .Case("nvptx", nvptx)
226 .Case("nvptx64", nvptx64)
229 .Case("amdil", amdil)
230 .Case("amdil64", amdil64)
231 .Case("hsail", hsail)
232 .Case("hsail64", hsail64)
234 .Case("spir64", spir64)
235 .Case("kalimba", kalimba)
236 .Default(UnknownArch);
239 static Triple::ArchType parseARMArch(StringRef ArchName) {
240 unsigned ISA = ARMTargetParser::parseArchISA(ArchName);
241 unsigned ENDIAN = ARMTargetParser::parseArchEndian(ArchName);
243 Triple::ArchType arch = Triple::UnknownArch;
245 case ARM::EK_LITTLE: {
251 arch = Triple::thumb;
253 case ARM::IK_AARCH64:
254 arch = Triple::aarch64;
262 arch = Triple::armeb;
265 arch = Triple::thumbeb;
267 case ARM::IK_AARCH64:
268 arch = Triple::aarch64_be;
275 ArchName = ARMTargetParser::getCanonicalArchName(ArchName);
276 if (ArchName.empty())
277 return Triple::UnknownArch;
279 // Thumb only exists in v4+
280 if (ISA == ARM::IK_THUMB &&
281 (ArchName.startswith("v2") || ArchName.startswith("v3")))
282 return Triple::UnknownArch;
284 // Thumb only for v6m
285 unsigned Profile = ARMTargetParser::parseArchProfile(ArchName);
286 unsigned Version = ARMTargetParser::parseArchVersion(ArchName);
287 if (Profile == ARM::PK_M && Version == 6) {
288 if (ENDIAN == ARM::EK_BIG)
289 return Triple::thumbeb;
291 return Triple::thumb;
297 static Triple::ArchType parseArch(StringRef ArchName) {
298 Triple::ArchType ARMArch(parseARMArch(ArchName));
300 return StringSwitch<Triple::ArchType>(ArchName)
301 .Cases("i386", "i486", "i586", "i686", Triple::x86)
302 // FIXME: Do we need to support these?
303 .Cases("i786", "i886", "i986", Triple::x86)
304 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
305 .Case("powerpc", Triple::ppc)
306 .Cases("powerpc64", "ppu", Triple::ppc64)
307 .Case("powerpc64le", Triple::ppc64le)
308 .Case("xscale", Triple::arm)
309 .Case("xscaleeb", Triple::armeb)
310 .StartsWith("arm", ARMArch)
311 .StartsWith("thumb", ARMArch)
312 .StartsWith("aarch64", ARMArch)
313 .Case("msp430", Triple::msp430)
314 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
315 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
316 .Cases("mips64", "mips64eb", Triple::mips64)
317 .Case("mips64el", Triple::mips64el)
318 .Case("r600", Triple::r600)
319 .Case("amdgcn", Triple::amdgcn)
320 .Case("bpf", Triple::bpf)
321 .Case("hexagon", Triple::hexagon)
322 .Case("s390x", Triple::systemz)
323 .Case("sparc", Triple::sparc)
324 .Case("sparcel", Triple::sparcel)
325 .Cases("sparcv9", "sparc64", Triple::sparcv9)
326 .Case("tce", Triple::tce)
327 .Case("xcore", Triple::xcore)
328 .Case("nvptx", Triple::nvptx)
329 .Case("nvptx64", Triple::nvptx64)
330 .Case("le32", Triple::le32)
331 .Case("le64", Triple::le64)
332 .Case("amdil", Triple::amdil)
333 .Case("amdil64", Triple::amdil64)
334 .Case("hsail", Triple::hsail)
335 .Case("hsail64", Triple::hsail64)
336 .Case("spir", Triple::spir)
337 .Case("spir64", Triple::spir64)
338 .StartsWith("kalimba", Triple::kalimba)
339 .Default(Triple::UnknownArch);
342 static Triple::VendorType parseVendor(StringRef VendorName) {
343 return StringSwitch<Triple::VendorType>(VendorName)
344 .Case("apple", Triple::Apple)
345 .Case("pc", Triple::PC)
346 .Case("scei", Triple::SCEI)
347 .Case("bgp", Triple::BGP)
348 .Case("bgq", Triple::BGQ)
349 .Case("fsl", Triple::Freescale)
350 .Case("ibm", Triple::IBM)
351 .Case("img", Triple::ImaginationTechnologies)
352 .Case("mti", Triple::MipsTechnologies)
353 .Case("nvidia", Triple::NVIDIA)
354 .Case("csr", Triple::CSR)
355 .Default(Triple::UnknownVendor);
358 static Triple::OSType parseOS(StringRef OSName) {
359 return StringSwitch<Triple::OSType>(OSName)
360 .StartsWith("cloudabi", Triple::CloudABI)
361 .StartsWith("darwin", Triple::Darwin)
362 .StartsWith("dragonfly", Triple::DragonFly)
363 .StartsWith("freebsd", Triple::FreeBSD)
364 .StartsWith("ios", Triple::IOS)
365 .StartsWith("kfreebsd", Triple::KFreeBSD)
366 .StartsWith("linux", Triple::Linux)
367 .StartsWith("lv2", Triple::Lv2)
368 .StartsWith("macosx", Triple::MacOSX)
369 .StartsWith("netbsd", Triple::NetBSD)
370 .StartsWith("openbsd", Triple::OpenBSD)
371 .StartsWith("solaris", Triple::Solaris)
372 .StartsWith("win32", Triple::Win32)
373 .StartsWith("windows", Triple::Win32)
374 .StartsWith("haiku", Triple::Haiku)
375 .StartsWith("minix", Triple::Minix)
376 .StartsWith("rtems", Triple::RTEMS)
377 .StartsWith("nacl", Triple::NaCl)
378 .StartsWith("cnk", Triple::CNK)
379 .StartsWith("bitrig", Triple::Bitrig)
380 .StartsWith("aix", Triple::AIX)
381 .StartsWith("cuda", Triple::CUDA)
382 .StartsWith("nvcl", Triple::NVCL)
383 .StartsWith("amdhsa", Triple::AMDHSA)
384 .StartsWith("ps4", Triple::PS4)
385 .Default(Triple::UnknownOS);
388 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
389 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
390 .StartsWith("eabihf", Triple::EABIHF)
391 .StartsWith("eabi", Triple::EABI)
392 .StartsWith("gnueabihf", Triple::GNUEABIHF)
393 .StartsWith("gnueabi", Triple::GNUEABI)
394 .StartsWith("gnux32", Triple::GNUX32)
395 .StartsWith("code16", Triple::CODE16)
396 .StartsWith("gnu", Triple::GNU)
397 .StartsWith("android", Triple::Android)
398 .StartsWith("msvc", Triple::MSVC)
399 .StartsWith("itanium", Triple::Itanium)
400 .StartsWith("cygnus", Triple::Cygnus)
401 .Default(Triple::UnknownEnvironment);
404 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
405 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
406 .EndsWith("coff", Triple::COFF)
407 .EndsWith("elf", Triple::ELF)
408 .EndsWith("macho", Triple::MachO)
409 .Default(Triple::UnknownObjectFormat);
412 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
413 StringRef ARMSubArch = ARMTargetParser::getCanonicalArchName(SubArchName);
415 // For now, this is the small part. Early return.
416 if (ARMSubArch.empty())
417 return StringSwitch<Triple::SubArchType>(SubArchName)
418 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
419 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
420 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
421 .Default(Triple::NoSubArch);
424 switch(ARMTargetParser::parseArch(ARMSubArch)) {
426 return Triple::NoSubArch;
428 return Triple::ARMSubArch_v4t;
432 return Triple::ARMSubArch_v5;
433 case ARM::AK_ARMV5TE:
435 case ARM::AK_IWMMXT2:
437 case ARM::AK_ARMV5TEJ:
438 return Triple::ARMSubArch_v5te;
442 return Triple::ARMSubArch_v6;
444 case ARM::AK_ARMV6ZK:
445 case ARM::AK_ARMV6HL:
446 return Triple::ARMSubArch_v6k;
447 case ARM::AK_ARMV6T2:
448 return Triple::ARMSubArch_v6t2;
450 case ARM::AK_ARMV6SM:
451 return Triple::ARMSubArch_v6m;
456 case ARM::AK_ARMV7HL:
457 return Triple::ARMSubArch_v7;
459 return Triple::ARMSubArch_v7m;
461 return Triple::ARMSubArch_v7s;
462 case ARM::AK_ARMV7EM:
463 return Triple::ARMSubArch_v7em;
465 return Triple::ARMSubArch_v8;
466 case ARM::AK_ARMV8_1A:
467 return Triple::ARMSubArch_v8_1a;
469 return Triple::NoSubArch;
473 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
475 case Triple::UnknownObjectFormat: return "";
476 case Triple::COFF: return "coff";
477 case Triple::ELF: return "elf";
478 case Triple::MachO: return "macho";
480 llvm_unreachable("unknown object format type");
483 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
484 switch (T.getArch()) {
487 case Triple::hexagon:
491 case Triple::mips64el:
495 case Triple::sparcv9:
496 case Triple::systemz:
498 case Triple::ppc64le:
504 return Triple::MachO;
509 return Triple::MachO;
510 else if (T.isOSWindows())
515 /// \brief Construct a triple from the string representation provided.
517 /// This stores the string representation and parses the various pieces into
519 Triple::Triple(const Twine &Str)
521 Arch(parseArch(getArchName())),
522 SubArch(parseSubArch(getArchName())),
523 Vendor(parseVendor(getVendorName())),
524 OS(parseOS(getOSName())),
525 Environment(parseEnvironment(getEnvironmentName())),
526 ObjectFormat(parseFormat(getEnvironmentName())) {
527 if (ObjectFormat == Triple::UnknownObjectFormat)
528 ObjectFormat = getDefaultFormat(*this);
531 /// \brief Construct a triple from string representations of the architecture,
534 /// This joins each argument into a canonical string representation and parses
535 /// them into enum members. It leaves the environment unknown and omits it from
536 /// the string representation.
537 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
538 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
539 Arch(parseArch(ArchStr.str())),
540 SubArch(parseSubArch(ArchStr.str())),
541 Vendor(parseVendor(VendorStr.str())),
542 OS(parseOS(OSStr.str())),
543 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
544 ObjectFormat = getDefaultFormat(*this);
547 /// \brief Construct a triple from string representations of the architecture,
548 /// vendor, OS, and environment.
550 /// This joins each argument into a canonical string representation and parses
551 /// them into enum members.
552 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
553 const Twine &EnvironmentStr)
554 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
555 EnvironmentStr).str()),
556 Arch(parseArch(ArchStr.str())),
557 SubArch(parseSubArch(ArchStr.str())),
558 Vendor(parseVendor(VendorStr.str())),
559 OS(parseOS(OSStr.str())),
560 Environment(parseEnvironment(EnvironmentStr.str())),
561 ObjectFormat(parseFormat(EnvironmentStr.str())) {
562 if (ObjectFormat == Triple::UnknownObjectFormat)
563 ObjectFormat = getDefaultFormat(*this);
566 std::string Triple::normalize(StringRef Str) {
567 bool IsMinGW32 = false;
568 bool IsCygwin = false;
570 // Parse into components.
571 SmallVector<StringRef, 4> Components;
572 Str.split(Components, "-");
574 // If the first component corresponds to a known architecture, preferentially
575 // use it for the architecture. If the second component corresponds to a
576 // known vendor, preferentially use it for the vendor, etc. This avoids silly
577 // component movement when a component parses as (eg) both a valid arch and a
579 ArchType Arch = UnknownArch;
580 if (Components.size() > 0)
581 Arch = parseArch(Components[0]);
582 VendorType Vendor = UnknownVendor;
583 if (Components.size() > 1)
584 Vendor = parseVendor(Components[1]);
585 OSType OS = UnknownOS;
586 if (Components.size() > 2) {
587 OS = parseOS(Components[2]);
588 IsCygwin = Components[2].startswith("cygwin");
589 IsMinGW32 = Components[2].startswith("mingw");
591 EnvironmentType Environment = UnknownEnvironment;
592 if (Components.size() > 3)
593 Environment = parseEnvironment(Components[3]);
594 ObjectFormatType ObjectFormat = UnknownObjectFormat;
595 if (Components.size() > 4)
596 ObjectFormat = parseFormat(Components[4]);
598 // Note which components are already in their final position. These will not
601 Found[0] = Arch != UnknownArch;
602 Found[1] = Vendor != UnknownVendor;
603 Found[2] = OS != UnknownOS;
604 Found[3] = Environment != UnknownEnvironment;
606 // If they are not there already, permute the components into their canonical
607 // positions by seeing if they parse as a valid architecture, and if so moving
608 // the component to the architecture position etc.
609 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
611 continue; // Already in the canonical position.
613 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
614 // Do not reparse any components that already matched.
615 if (Idx < array_lengthof(Found) && Found[Idx])
618 // Does this component parse as valid for the target position?
620 StringRef Comp = Components[Idx];
622 default: llvm_unreachable("unexpected component type!");
624 Arch = parseArch(Comp);
625 Valid = Arch != UnknownArch;
628 Vendor = parseVendor(Comp);
629 Valid = Vendor != UnknownVendor;
633 IsCygwin = Comp.startswith("cygwin");
634 IsMinGW32 = Comp.startswith("mingw");
635 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
638 Environment = parseEnvironment(Comp);
639 Valid = Environment != UnknownEnvironment;
641 ObjectFormat = parseFormat(Comp);
642 Valid = ObjectFormat != UnknownObjectFormat;
647 continue; // Nope, try the next component.
649 // Move the component to the target position, pushing any non-fixed
650 // components that are in the way to the right. This tends to give
651 // good results in the common cases of a forgotten vendor component
652 // or a wrongly positioned environment.
654 // Insert left, pushing the existing components to the right. For
655 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
656 StringRef CurrentComponent(""); // The empty component.
657 // Replace the component we are moving with an empty component.
658 std::swap(CurrentComponent, Components[Idx]);
659 // Insert the component being moved at Pos, displacing any existing
660 // components to the right.
661 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
662 // Skip over any fixed components.
663 while (i < array_lengthof(Found) && Found[i])
665 // Place the component at the new position, getting the component
666 // that was at this position - it will be moved right.
667 std::swap(CurrentComponent, Components[i]);
669 } else if (Pos > Idx) {
670 // Push right by inserting empty components until the component at Idx
671 // reaches the target position Pos. For example, pc-a -> -pc-a when
672 // moving pc to the second position.
674 // Insert one empty component at Idx.
675 StringRef CurrentComponent(""); // The empty component.
676 for (unsigned i = Idx; i < Components.size();) {
677 // Place the component at the new position, getting the component
678 // that was at this position - it will be moved right.
679 std::swap(CurrentComponent, Components[i]);
680 // If it was placed on top of an empty component then we are done.
681 if (CurrentComponent.empty())
683 // Advance to the next component, skipping any fixed components.
684 while (++i < array_lengthof(Found) && Found[i])
687 // The last component was pushed off the end - append it.
688 if (!CurrentComponent.empty())
689 Components.push_back(CurrentComponent);
691 // Advance Idx to the component's new position.
692 while (++Idx < array_lengthof(Found) && Found[Idx])
694 } while (Idx < Pos); // Add more until the final position is reached.
696 assert(Pos < Components.size() && Components[Pos] == Comp &&
697 "Component moved wrong!");
703 // Special case logic goes here. At this point Arch, Vendor and OS have the
704 // correct values for the computed components.
705 std::string NormalizedEnvironment;
706 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
707 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
708 if (AndroidVersion.empty()) {
709 Components[3] = "android";
711 NormalizedEnvironment = Twine("android", AndroidVersion).str();
712 Components[3] = NormalizedEnvironment;
716 if (OS == Triple::Win32) {
717 Components.resize(4);
718 Components[2] = "windows";
719 if (Environment == UnknownEnvironment) {
720 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
721 Components[3] = "msvc";
723 Components[3] = getObjectFormatTypeName(ObjectFormat);
725 } else if (IsMinGW32) {
726 Components.resize(4);
727 Components[2] = "windows";
728 Components[3] = "gnu";
729 } else if (IsCygwin) {
730 Components.resize(4);
731 Components[2] = "windows";
732 Components[3] = "cygnus";
734 if (IsMinGW32 || IsCygwin ||
735 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
736 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
737 Components.resize(5);
738 Components[4] = getObjectFormatTypeName(ObjectFormat);
742 // Stick the corrected components back together to form the normalized string.
743 std::string Normalized;
744 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
745 if (i) Normalized += '-';
746 Normalized += Components[i];
751 StringRef Triple::getArchName() const {
752 return StringRef(Data).split('-').first; // Isolate first component
755 StringRef Triple::getVendorName() const {
756 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
757 return Tmp.split('-').first; // Isolate second component
760 StringRef Triple::getOSName() const {
761 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
762 Tmp = Tmp.split('-').second; // Strip second component
763 return Tmp.split('-').first; // Isolate third component
766 StringRef Triple::getEnvironmentName() const {
767 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
768 Tmp = Tmp.split('-').second; // Strip second component
769 return Tmp.split('-').second; // Strip third component
772 StringRef Triple::getOSAndEnvironmentName() const {
773 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
774 return Tmp.split('-').second; // Strip second component
777 static unsigned EatNumber(StringRef &Str) {
778 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
782 // Consume the leading digit.
783 Result = Result*10 + (Str[0] - '0');
787 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
792 static void parseVersionFromName(StringRef Name, unsigned &Major,
793 unsigned &Minor, unsigned &Micro) {
794 // Any unset version defaults to 0.
795 Major = Minor = Micro = 0;
797 // Parse up to three components.
798 unsigned *Components[3] = {&Major, &Minor, &Micro};
799 for (unsigned i = 0; i != 3; ++i) {
800 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
803 // Consume the leading number.
804 *Components[i] = EatNumber(Name);
806 // Consume the separator, if present.
807 if (Name.startswith("."))
808 Name = Name.substr(1);
812 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
813 unsigned &Micro) const {
814 StringRef EnvironmentName = getEnvironmentName();
815 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
816 if (EnvironmentName.startswith(EnvironmentTypeName))
817 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
818 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
821 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
822 unsigned &Micro) const {
823 StringRef OSName = getOSName();
825 // For Android, we care about the Android version rather than the Linux
827 if (getEnvironment() == Android) {
828 OSName = getEnvironmentName().substr(strlen("android"));
829 if (OSName.startswith("eabi"))
830 OSName = OSName.substr(strlen("eabi"));
833 // Assume that the OS portion of the triple starts with the canonical name.
834 StringRef OSTypeName = getOSTypeName(getOS());
835 if (OSName.startswith(OSTypeName))
836 OSName = OSName.substr(OSTypeName.size());
838 parseVersionFromName(OSName, Major, Minor, Micro);
841 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
842 unsigned &Micro) const {
843 getOSVersion(Major, Minor, Micro);
846 default: llvm_unreachable("unexpected OS for Darwin triple");
848 // Default to darwin8, i.e., MacOSX 10.4.
851 // Darwin version numbers are skewed from OS X versions.
868 // Ignore the version from the triple. This is only handled because the
869 // the clang driver combines OS X and IOS support into a common Darwin
870 // toolchain that wants to know the OS X version number even when targeting
880 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
881 unsigned &Micro) const {
883 default: llvm_unreachable("unexpected OS for Darwin triple");
886 // Ignore the version from the triple. This is only handled because the
887 // the clang driver combines OS X and IOS support into a common Darwin
888 // toolchain that wants to know the iOS version number even when targeting
895 getOSVersion(Major, Minor, Micro);
896 // Default to 5.0 (or 7.0 for arm64).
898 Major = (getArch() == aarch64) ? 7 : 5;
903 void Triple::setTriple(const Twine &Str) {
907 void Triple::setArch(ArchType Kind) {
908 setArchName(getArchTypeName(Kind));
911 void Triple::setVendor(VendorType Kind) {
912 setVendorName(getVendorTypeName(Kind));
915 void Triple::setOS(OSType Kind) {
916 setOSName(getOSTypeName(Kind));
919 void Triple::setEnvironment(EnvironmentType Kind) {
920 if (ObjectFormat == getDefaultFormat(*this))
921 return setEnvironmentName(getEnvironmentTypeName(Kind));
923 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
924 getObjectFormatTypeName(ObjectFormat)).str());
927 void Triple::setObjectFormat(ObjectFormatType Kind) {
928 if (Environment == UnknownEnvironment)
929 return setEnvironmentName(getObjectFormatTypeName(Kind));
931 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
932 getObjectFormatTypeName(Kind)).str());
935 void Triple::setArchName(StringRef Str) {
936 // Work around a miscompilation bug for Twines in gcc 4.0.3.
937 SmallString<64> Triple;
940 Triple += getVendorName();
942 Triple += getOSAndEnvironmentName();
946 void Triple::setVendorName(StringRef Str) {
947 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
950 void Triple::setOSName(StringRef Str) {
951 if (hasEnvironment())
952 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
953 "-" + getEnvironmentName());
955 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
958 void Triple::setEnvironmentName(StringRef Str) {
959 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
963 void Triple::setOSAndEnvironmentName(StringRef Str) {
964 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
967 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
969 case llvm::Triple::UnknownArch:
972 case llvm::Triple::msp430:
975 case llvm::Triple::arm:
976 case llvm::Triple::armeb:
977 case llvm::Triple::hexagon:
978 case llvm::Triple::le32:
979 case llvm::Triple::mips:
980 case llvm::Triple::mipsel:
981 case llvm::Triple::nvptx:
982 case llvm::Triple::ppc:
983 case llvm::Triple::r600:
984 case llvm::Triple::sparc:
985 case llvm::Triple::sparcel:
986 case llvm::Triple::tce:
987 case llvm::Triple::thumb:
988 case llvm::Triple::thumbeb:
989 case llvm::Triple::x86:
990 case llvm::Triple::xcore:
991 case llvm::Triple::amdil:
992 case llvm::Triple::hsail:
993 case llvm::Triple::spir:
994 case llvm::Triple::kalimba:
997 case llvm::Triple::aarch64:
998 case llvm::Triple::aarch64_be:
999 case llvm::Triple::amdgcn:
1000 case llvm::Triple::bpf:
1001 case llvm::Triple::le64:
1002 case llvm::Triple::mips64:
1003 case llvm::Triple::mips64el:
1004 case llvm::Triple::nvptx64:
1005 case llvm::Triple::ppc64:
1006 case llvm::Triple::ppc64le:
1007 case llvm::Triple::sparcv9:
1008 case llvm::Triple::systemz:
1009 case llvm::Triple::x86_64:
1010 case llvm::Triple::amdil64:
1011 case llvm::Triple::hsail64:
1012 case llvm::Triple::spir64:
1015 llvm_unreachable("Invalid architecture value");
1018 bool Triple::isArch64Bit() const {
1019 return getArchPointerBitWidth(getArch()) == 64;
1022 bool Triple::isArch32Bit() const {
1023 return getArchPointerBitWidth(getArch()) == 32;
1026 bool Triple::isArch16Bit() const {
1027 return getArchPointerBitWidth(getArch()) == 16;
1030 Triple Triple::get32BitArchVariant() const {
1032 switch (getArch()) {
1033 case Triple::UnknownArch:
1034 case Triple::aarch64:
1035 case Triple::aarch64_be:
1036 case Triple::amdgcn:
1038 case Triple::msp430:
1039 case Triple::systemz:
1040 case Triple::ppc64le:
1041 T.setArch(UnknownArch);
1049 case Triple::hexagon:
1050 case Triple::kalimba:
1053 case Triple::mipsel:
1058 case Triple::sparcel:
1061 case Triple::thumbeb:
1067 case Triple::le64: T.setArch(Triple::le32); break;
1068 case Triple::mips64: T.setArch(Triple::mips); break;
1069 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1070 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1071 case Triple::ppc64: T.setArch(Triple::ppc); break;
1072 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1073 case Triple::x86_64: T.setArch(Triple::x86); break;
1074 case Triple::amdil64: T.setArch(Triple::amdil); break;
1075 case Triple::hsail64: T.setArch(Triple::hsail); break;
1076 case Triple::spir64: T.setArch(Triple::spir); break;
1081 Triple Triple::get64BitArchVariant() const {
1083 switch (getArch()) {
1084 case Triple::UnknownArch:
1087 case Triple::hexagon:
1088 case Triple::kalimba:
1089 case Triple::msp430:
1093 case Triple::thumbeb:
1095 case Triple::sparcel:
1096 T.setArch(UnknownArch);
1099 case Triple::aarch64:
1100 case Triple::aarch64_be:
1103 case Triple::amdil64:
1104 case Triple::amdgcn:
1105 case Triple::hsail64:
1106 case Triple::spir64:
1107 case Triple::mips64:
1108 case Triple::mips64el:
1109 case Triple::nvptx64:
1111 case Triple::ppc64le:
1112 case Triple::sparcv9:
1113 case Triple::systemz:
1114 case Triple::x86_64:
1118 case Triple::le32: T.setArch(Triple::le64); break;
1119 case Triple::mips: T.setArch(Triple::mips64); break;
1120 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1121 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1122 case Triple::ppc: T.setArch(Triple::ppc64); break;
1123 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1124 case Triple::x86: T.setArch(Triple::x86_64); break;
1125 case Triple::amdil: T.setArch(Triple::amdil64); break;
1126 case Triple::hsail: T.setArch(Triple::hsail64); break;
1127 case Triple::spir: T.setArch(Triple::spir64); break;
1132 const char *Triple::getARMCPUForArch(StringRef MArch) const {
1134 MArch = getArchName();
1136 // Some defaults are forced.
1138 case llvm::Triple::FreeBSD:
1139 case llvm::Triple::NetBSD:
1140 MArch = ARMTargetParser::getCanonicalArchName(MArch);
1141 if (!MArch.empty() && MArch == "v6")
1142 return "arm1176jzf-s";
1144 case llvm::Triple::Win32:
1145 // FIXME: this is invalid for WindowsCE
1151 MArch = ARMTargetParser::getCanonicalArchName(MArch);
1155 const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
1159 // If no specific architecture version is requested, return the minimum CPU
1160 // required by the OS and environment.
1162 case llvm::Triple::NetBSD:
1163 switch (getEnvironment()) {
1164 case llvm::Triple::GNUEABIHF:
1165 case llvm::Triple::GNUEABI:
1166 case llvm::Triple::EABIHF:
1167 case llvm::Triple::EABI:
1168 return "arm926ej-s";
1172 case llvm::Triple::NaCl:
1175 switch (getEnvironment()) {
1176 case llvm::Triple::EABIHF:
1177 case llvm::Triple::GNUEABIHF:
1178 return "arm1176jzf-s";
1184 llvm_unreachable("invalid arch name");