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 bpf_le: return "bpf_le";
29 case bpf_be: return "bpf_be";
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";
64 llvm_unreachable("Invalid ArchType!");
67 const char *Triple::getArchTypePrefix(ArchType Kind) {
73 case aarch64_be: return "aarch64";
78 case thumbeb: return "arm";
82 case ppc: return "ppc";
87 case mips64el: return "mips";
89 case hexagon: return "hexagon";
92 case r600: return "amdgpu";
95 case bpf_be: return "bpf";
99 case sparc: return "sparc";
101 case systemz: return "s390";
104 case x86_64: return "x86";
106 case xcore: return "xcore";
108 case nvptx: return "nvptx";
109 case nvptx64: return "nvptx";
111 case le32: return "le32";
112 case le64: return "le64";
115 case amdil64: return "amdil";
118 case hsail64: return "hsail";
121 case spir64: return "spir";
122 case kalimba: return "kalimba";
126 const char *Triple::getVendorTypeName(VendorType Kind) {
128 case UnknownVendor: return "unknown";
130 case Apple: return "apple";
131 case PC: return "pc";
132 case SCEI: return "scei";
133 case BGP: return "bgp";
134 case BGQ: return "bgq";
135 case Freescale: return "fsl";
136 case IBM: return "ibm";
137 case ImaginationTechnologies: return "img";
138 case MipsTechnologies: return "mti";
139 case NVIDIA: return "nvidia";
140 case CSR: return "csr";
143 llvm_unreachable("Invalid VendorType!");
146 const char *Triple::getOSTypeName(OSType Kind) {
148 case UnknownOS: return "unknown";
150 case CloudABI: return "cloudabi";
151 case Darwin: return "darwin";
152 case DragonFly: return "dragonfly";
153 case FreeBSD: return "freebsd";
154 case IOS: return "ios";
155 case KFreeBSD: return "kfreebsd";
156 case Linux: return "linux";
157 case Lv2: return "lv2";
158 case MacOSX: return "macosx";
159 case NetBSD: return "netbsd";
160 case OpenBSD: return "openbsd";
161 case Solaris: return "solaris";
162 case Win32: return "windows";
163 case Haiku: return "haiku";
164 case Minix: return "minix";
165 case RTEMS: return "rtems";
166 case NaCl: return "nacl";
167 case CNK: return "cnk";
168 case Bitrig: return "bitrig";
169 case AIX: return "aix";
170 case CUDA: return "cuda";
171 case NVCL: return "nvcl";
172 case AMDHSA: return "amdhsa";
173 case PS4: return "ps4";
176 llvm_unreachable("Invalid OSType");
179 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
181 case UnknownEnvironment: return "unknown";
182 case GNU: return "gnu";
183 case GNUEABIHF: return "gnueabihf";
184 case GNUEABI: return "gnueabi";
185 case GNUX32: return "gnux32";
186 case CODE16: return "code16";
187 case EABI: return "eabi";
188 case EABIHF: return "eabihf";
189 case Android: return "android";
190 case MSVC: return "msvc";
191 case Itanium: return "itanium";
192 case Cygnus: return "cygnus";
195 llvm_unreachable("Invalid EnvironmentType!");
198 static Triple::ArchType parseBPFArch(StringRef ArchName) {
199 if (ArchName.equals("bpf")) {
200 if (sys::IsLittleEndianHost)
201 return Triple::bpf_le;
203 return Triple::bpf_be;
204 } else if (ArchName.equals("bpf_be")) {
205 return Triple::bpf_be;
206 } else if (ArchName.equals("bpf_le")) {
207 return Triple::bpf_le;
209 return Triple::UnknownArch;
213 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
214 Triple::ArchType BPFArch(parseBPFArch(Name));
215 return StringSwitch<Triple::ArchType>(Name)
216 .Case("aarch64", aarch64)
217 .Case("aarch64_be", aarch64_be)
218 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
220 .Case("armeb", armeb)
221 .StartsWith("bpf", BPFArch)
223 .Case("mipsel", mipsel)
224 .Case("mips64", mips64)
225 .Case("mips64el", mips64el)
226 .Case("msp430", msp430)
227 .Case("ppc64", ppc64)
230 .Case("ppc64le", ppc64le)
232 .Case("amdgcn", amdgcn)
233 .Case("hexagon", hexagon)
234 .Case("sparc", sparc)
235 .Case("sparcel", sparcel)
236 .Case("sparcv9", sparcv9)
237 .Case("systemz", systemz)
239 .Case("thumb", thumb)
240 .Case("thumbeb", thumbeb)
242 .Case("x86-64", x86_64)
243 .Case("xcore", xcore)
244 .Case("nvptx", nvptx)
245 .Case("nvptx64", nvptx64)
248 .Case("amdil", amdil)
249 .Case("amdil64", amdil64)
250 .Case("hsail", hsail)
251 .Case("hsail64", hsail64)
253 .Case("spir64", spir64)
254 .Case("kalimba", kalimba)
255 .Default(UnknownArch);
258 static Triple::ArchType parseARMArch(StringRef ArchName) {
259 unsigned ISA = ARMTargetParser::parseArchISA(ArchName);
260 unsigned ENDIAN = ARMTargetParser::parseArchEndian(ArchName);
262 Triple::ArchType arch = Triple::UnknownArch;
264 case ARM::EK_LITTLE: {
270 arch = Triple::thumb;
272 case ARM::IK_AARCH64:
273 arch = Triple::aarch64;
281 arch = Triple::armeb;
284 arch = Triple::thumbeb;
286 case ARM::IK_AARCH64:
287 arch = Triple::aarch64_be;
294 ArchName = ARMTargetParser::getCanonicalArchName(ArchName);
295 if (ArchName.empty())
296 return Triple::UnknownArch;
298 // Thumb only exists in v4+
299 if (ISA == ARM::IK_THUMB &&
300 (ArchName.startswith("v2") || ArchName.startswith("v3")))
301 return Triple::UnknownArch;
303 // Thumb only for v6m
304 unsigned Profile = ARMTargetParser::parseArchProfile(ArchName);
305 unsigned Version = ARMTargetParser::parseArchVersion(ArchName);
306 if (Profile == ARM::PK_M && Version == 6) {
307 if (ENDIAN == ARM::EK_BIG)
308 return Triple::thumbeb;
310 return Triple::thumb;
316 static Triple::ArchType parseArch(StringRef ArchName) {
317 Triple::ArchType ARMArch(parseARMArch(ArchName));
318 Triple::ArchType BPFArch(parseBPFArch(ArchName));
320 return StringSwitch<Triple::ArchType>(ArchName)
321 .Cases("i386", "i486", "i586", "i686", Triple::x86)
322 // FIXME: Do we need to support these?
323 .Cases("i786", "i886", "i986", Triple::x86)
324 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
325 .Case("powerpc", Triple::ppc)
326 .Cases("powerpc64", "ppu", Triple::ppc64)
327 .Case("powerpc64le", Triple::ppc64le)
328 .Case("xscale", Triple::arm)
329 .Case("xscaleeb", Triple::armeb)
330 .StartsWith("arm", ARMArch)
331 .StartsWith("thumb", ARMArch)
332 .StartsWith("aarch64", ARMArch)
333 .Case("msp430", Triple::msp430)
334 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
335 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
336 .Cases("mips64", "mips64eb", Triple::mips64)
337 .Case("mips64el", Triple::mips64el)
338 .Case("r600", Triple::r600)
339 .Case("amdgcn", Triple::amdgcn)
340 .StartsWith("bpf", BPFArch)
341 .Case("hexagon", Triple::hexagon)
342 .Case("s390x", Triple::systemz)
343 .Case("sparc", Triple::sparc)
344 .Case("sparcel", Triple::sparcel)
345 .Cases("sparcv9", "sparc64", Triple::sparcv9)
346 .Case("tce", Triple::tce)
347 .Case("xcore", Triple::xcore)
348 .Case("nvptx", Triple::nvptx)
349 .Case("nvptx64", Triple::nvptx64)
350 .Case("le32", Triple::le32)
351 .Case("le64", Triple::le64)
352 .Case("amdil", Triple::amdil)
353 .Case("amdil64", Triple::amdil64)
354 .Case("hsail", Triple::hsail)
355 .Case("hsail64", Triple::hsail64)
356 .Case("spir", Triple::spir)
357 .Case("spir64", Triple::spir64)
358 .StartsWith("kalimba", Triple::kalimba)
359 .Default(Triple::UnknownArch);
362 static Triple::VendorType parseVendor(StringRef VendorName) {
363 return StringSwitch<Triple::VendorType>(VendorName)
364 .Case("apple", Triple::Apple)
365 .Case("pc", Triple::PC)
366 .Case("scei", Triple::SCEI)
367 .Case("bgp", Triple::BGP)
368 .Case("bgq", Triple::BGQ)
369 .Case("fsl", Triple::Freescale)
370 .Case("ibm", Triple::IBM)
371 .Case("img", Triple::ImaginationTechnologies)
372 .Case("mti", Triple::MipsTechnologies)
373 .Case("nvidia", Triple::NVIDIA)
374 .Case("csr", Triple::CSR)
375 .Default(Triple::UnknownVendor);
378 static Triple::OSType parseOS(StringRef OSName) {
379 return StringSwitch<Triple::OSType>(OSName)
380 .StartsWith("cloudabi", Triple::CloudABI)
381 .StartsWith("darwin", Triple::Darwin)
382 .StartsWith("dragonfly", Triple::DragonFly)
383 .StartsWith("freebsd", Triple::FreeBSD)
384 .StartsWith("ios", Triple::IOS)
385 .StartsWith("kfreebsd", Triple::KFreeBSD)
386 .StartsWith("linux", Triple::Linux)
387 .StartsWith("lv2", Triple::Lv2)
388 .StartsWith("macosx", Triple::MacOSX)
389 .StartsWith("netbsd", Triple::NetBSD)
390 .StartsWith("openbsd", Triple::OpenBSD)
391 .StartsWith("solaris", Triple::Solaris)
392 .StartsWith("win32", Triple::Win32)
393 .StartsWith("windows", Triple::Win32)
394 .StartsWith("haiku", Triple::Haiku)
395 .StartsWith("minix", Triple::Minix)
396 .StartsWith("rtems", Triple::RTEMS)
397 .StartsWith("nacl", Triple::NaCl)
398 .StartsWith("cnk", Triple::CNK)
399 .StartsWith("bitrig", Triple::Bitrig)
400 .StartsWith("aix", Triple::AIX)
401 .StartsWith("cuda", Triple::CUDA)
402 .StartsWith("nvcl", Triple::NVCL)
403 .StartsWith("amdhsa", Triple::AMDHSA)
404 .StartsWith("ps4", Triple::PS4)
405 .Default(Triple::UnknownOS);
408 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
409 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
410 .StartsWith("eabihf", Triple::EABIHF)
411 .StartsWith("eabi", Triple::EABI)
412 .StartsWith("gnueabihf", Triple::GNUEABIHF)
413 .StartsWith("gnueabi", Triple::GNUEABI)
414 .StartsWith("gnux32", Triple::GNUX32)
415 .StartsWith("code16", Triple::CODE16)
416 .StartsWith("gnu", Triple::GNU)
417 .StartsWith("android", Triple::Android)
418 .StartsWith("msvc", Triple::MSVC)
419 .StartsWith("itanium", Triple::Itanium)
420 .StartsWith("cygnus", Triple::Cygnus)
421 .Default(Triple::UnknownEnvironment);
424 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
425 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
426 .EndsWith("coff", Triple::COFF)
427 .EndsWith("elf", Triple::ELF)
428 .EndsWith("macho", Triple::MachO)
429 .Default(Triple::UnknownObjectFormat);
432 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
433 StringRef ARMSubArch = ARMTargetParser::getCanonicalArchName(SubArchName);
435 // For now, this is the small part. Early return.
436 if (ARMSubArch.empty())
437 return StringSwitch<Triple::SubArchType>(SubArchName)
438 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
439 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
440 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
441 .Default(Triple::NoSubArch);
444 switch(ARMTargetParser::parseArch(ARMSubArch)) {
446 return Triple::NoSubArch;
448 return Triple::ARMSubArch_v4t;
452 return Triple::ARMSubArch_v5;
453 case ARM::AK_ARMV5TE:
455 case ARM::AK_IWMMXT2:
457 case ARM::AK_ARMV5TEJ:
458 return Triple::ARMSubArch_v5te;
462 return Triple::ARMSubArch_v6;
464 case ARM::AK_ARMV6ZK:
465 case ARM::AK_ARMV6HL:
466 return Triple::ARMSubArch_v6k;
467 case ARM::AK_ARMV6T2:
468 return Triple::ARMSubArch_v6t2;
470 case ARM::AK_ARMV6SM:
471 return Triple::ARMSubArch_v6m;
476 case ARM::AK_ARMV7HL:
477 return Triple::ARMSubArch_v7;
479 return Triple::ARMSubArch_v7m;
481 return Triple::ARMSubArch_v7s;
482 case ARM::AK_ARMV7EM:
483 return Triple::ARMSubArch_v7em;
485 return Triple::ARMSubArch_v8;
486 case ARM::AK_ARMV8_1A:
487 return Triple::ARMSubArch_v8_1a;
489 return Triple::NoSubArch;
493 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
495 case Triple::UnknownObjectFormat: return "";
496 case Triple::COFF: return "coff";
497 case Triple::ELF: return "elf";
498 case Triple::MachO: return "macho";
500 llvm_unreachable("unknown object format type");
503 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
504 switch (T.getArch()) {
507 case Triple::hexagon:
511 case Triple::mips64el:
515 case Triple::sparcv9:
516 case Triple::systemz:
518 case Triple::ppc64le:
524 return Triple::MachO;
529 return Triple::MachO;
530 else if (T.isOSWindows())
535 /// \brief Construct a triple from the string representation provided.
537 /// This stores the string representation and parses the various pieces into
539 Triple::Triple(const Twine &Str)
541 Arch(parseArch(getArchName())),
542 SubArch(parseSubArch(getArchName())),
543 Vendor(parseVendor(getVendorName())),
544 OS(parseOS(getOSName())),
545 Environment(parseEnvironment(getEnvironmentName())),
546 ObjectFormat(parseFormat(getEnvironmentName())) {
547 if (ObjectFormat == Triple::UnknownObjectFormat)
548 ObjectFormat = getDefaultFormat(*this);
551 /// \brief Construct a triple from string representations of the architecture,
554 /// This joins each argument into a canonical string representation and parses
555 /// them into enum members. It leaves the environment unknown and omits it from
556 /// the string representation.
557 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
558 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
559 Arch(parseArch(ArchStr.str())),
560 SubArch(parseSubArch(ArchStr.str())),
561 Vendor(parseVendor(VendorStr.str())),
562 OS(parseOS(OSStr.str())),
563 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
564 ObjectFormat = getDefaultFormat(*this);
567 /// \brief Construct a triple from string representations of the architecture,
568 /// vendor, OS, and environment.
570 /// This joins each argument into a canonical string representation and parses
571 /// them into enum members.
572 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
573 const Twine &EnvironmentStr)
574 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
575 EnvironmentStr).str()),
576 Arch(parseArch(ArchStr.str())),
577 SubArch(parseSubArch(ArchStr.str())),
578 Vendor(parseVendor(VendorStr.str())),
579 OS(parseOS(OSStr.str())),
580 Environment(parseEnvironment(EnvironmentStr.str())),
581 ObjectFormat(parseFormat(EnvironmentStr.str())) {
582 if (ObjectFormat == Triple::UnknownObjectFormat)
583 ObjectFormat = getDefaultFormat(*this);
586 std::string Triple::normalize(StringRef Str) {
587 bool IsMinGW32 = false;
588 bool IsCygwin = false;
590 // Parse into components.
591 SmallVector<StringRef, 4> Components;
592 Str.split(Components, "-");
594 // If the first component corresponds to a known architecture, preferentially
595 // use it for the architecture. If the second component corresponds to a
596 // known vendor, preferentially use it for the vendor, etc. This avoids silly
597 // component movement when a component parses as (eg) both a valid arch and a
599 ArchType Arch = UnknownArch;
600 if (Components.size() > 0)
601 Arch = parseArch(Components[0]);
602 VendorType Vendor = UnknownVendor;
603 if (Components.size() > 1)
604 Vendor = parseVendor(Components[1]);
605 OSType OS = UnknownOS;
606 if (Components.size() > 2) {
607 OS = parseOS(Components[2]);
608 IsCygwin = Components[2].startswith("cygwin");
609 IsMinGW32 = Components[2].startswith("mingw");
611 EnvironmentType Environment = UnknownEnvironment;
612 if (Components.size() > 3)
613 Environment = parseEnvironment(Components[3]);
614 ObjectFormatType ObjectFormat = UnknownObjectFormat;
615 if (Components.size() > 4)
616 ObjectFormat = parseFormat(Components[4]);
618 // Note which components are already in their final position. These will not
621 Found[0] = Arch != UnknownArch;
622 Found[1] = Vendor != UnknownVendor;
623 Found[2] = OS != UnknownOS;
624 Found[3] = Environment != UnknownEnvironment;
626 // If they are not there already, permute the components into their canonical
627 // positions by seeing if they parse as a valid architecture, and if so moving
628 // the component to the architecture position etc.
629 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
631 continue; // Already in the canonical position.
633 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
634 // Do not reparse any components that already matched.
635 if (Idx < array_lengthof(Found) && Found[Idx])
638 // Does this component parse as valid for the target position?
640 StringRef Comp = Components[Idx];
642 default: llvm_unreachable("unexpected component type!");
644 Arch = parseArch(Comp);
645 Valid = Arch != UnknownArch;
648 Vendor = parseVendor(Comp);
649 Valid = Vendor != UnknownVendor;
653 IsCygwin = Comp.startswith("cygwin");
654 IsMinGW32 = Comp.startswith("mingw");
655 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
658 Environment = parseEnvironment(Comp);
659 Valid = Environment != UnknownEnvironment;
661 ObjectFormat = parseFormat(Comp);
662 Valid = ObjectFormat != UnknownObjectFormat;
667 continue; // Nope, try the next component.
669 // Move the component to the target position, pushing any non-fixed
670 // components that are in the way to the right. This tends to give
671 // good results in the common cases of a forgotten vendor component
672 // or a wrongly positioned environment.
674 // Insert left, pushing the existing components to the right. For
675 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
676 StringRef CurrentComponent(""); // The empty component.
677 // Replace the component we are moving with an empty component.
678 std::swap(CurrentComponent, Components[Idx]);
679 // Insert the component being moved at Pos, displacing any existing
680 // components to the right.
681 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
682 // Skip over any fixed components.
683 while (i < array_lengthof(Found) && Found[i])
685 // Place the component at the new position, getting the component
686 // that was at this position - it will be moved right.
687 std::swap(CurrentComponent, Components[i]);
689 } else if (Pos > Idx) {
690 // Push right by inserting empty components until the component at Idx
691 // reaches the target position Pos. For example, pc-a -> -pc-a when
692 // moving pc to the second position.
694 // Insert one empty component at Idx.
695 StringRef CurrentComponent(""); // The empty component.
696 for (unsigned i = Idx; i < Components.size();) {
697 // Place the component at the new position, getting the component
698 // that was at this position - it will be moved right.
699 std::swap(CurrentComponent, Components[i]);
700 // If it was placed on top of an empty component then we are done.
701 if (CurrentComponent.empty())
703 // Advance to the next component, skipping any fixed components.
704 while (++i < array_lengthof(Found) && Found[i])
707 // The last component was pushed off the end - append it.
708 if (!CurrentComponent.empty())
709 Components.push_back(CurrentComponent);
711 // Advance Idx to the component's new position.
712 while (++Idx < array_lengthof(Found) && Found[Idx])
714 } while (Idx < Pos); // Add more until the final position is reached.
716 assert(Pos < Components.size() && Components[Pos] == Comp &&
717 "Component moved wrong!");
723 // Special case logic goes here. At this point Arch, Vendor and OS have the
724 // correct values for the computed components.
725 std::string NormalizedEnvironment;
726 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
727 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
728 if (AndroidVersion.empty()) {
729 Components[3] = "android";
731 NormalizedEnvironment = Twine("android", AndroidVersion).str();
732 Components[3] = NormalizedEnvironment;
736 if (OS == Triple::Win32) {
737 Components.resize(4);
738 Components[2] = "windows";
739 if (Environment == UnknownEnvironment) {
740 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
741 Components[3] = "msvc";
743 Components[3] = getObjectFormatTypeName(ObjectFormat);
745 } else if (IsMinGW32) {
746 Components.resize(4);
747 Components[2] = "windows";
748 Components[3] = "gnu";
749 } else if (IsCygwin) {
750 Components.resize(4);
751 Components[2] = "windows";
752 Components[3] = "cygnus";
754 if (IsMinGW32 || IsCygwin ||
755 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
756 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
757 Components.resize(5);
758 Components[4] = getObjectFormatTypeName(ObjectFormat);
762 // Stick the corrected components back together to form the normalized string.
763 std::string Normalized;
764 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
765 if (i) Normalized += '-';
766 Normalized += Components[i];
771 StringRef Triple::getArchName() const {
772 return StringRef(Data).split('-').first; // Isolate first component
775 StringRef Triple::getVendorName() const {
776 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
777 return Tmp.split('-').first; // Isolate second component
780 StringRef Triple::getOSName() const {
781 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
782 Tmp = Tmp.split('-').second; // Strip second component
783 return Tmp.split('-').first; // Isolate third component
786 StringRef Triple::getEnvironmentName() const {
787 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
788 Tmp = Tmp.split('-').second; // Strip second component
789 return Tmp.split('-').second; // Strip third component
792 StringRef Triple::getOSAndEnvironmentName() const {
793 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
794 return Tmp.split('-').second; // Strip second component
797 static unsigned EatNumber(StringRef &Str) {
798 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
802 // Consume the leading digit.
803 Result = Result*10 + (Str[0] - '0');
807 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
812 static void parseVersionFromName(StringRef Name, unsigned &Major,
813 unsigned &Minor, unsigned &Micro) {
814 // Any unset version defaults to 0.
815 Major = Minor = Micro = 0;
817 // Parse up to three components.
818 unsigned *Components[3] = {&Major, &Minor, &Micro};
819 for (unsigned i = 0; i != 3; ++i) {
820 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
823 // Consume the leading number.
824 *Components[i] = EatNumber(Name);
826 // Consume the separator, if present.
827 if (Name.startswith("."))
828 Name = Name.substr(1);
832 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
833 unsigned &Micro) const {
834 StringRef EnvironmentName = getEnvironmentName();
835 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
836 if (EnvironmentName.startswith(EnvironmentTypeName))
837 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
839 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
842 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
843 unsigned &Micro) const {
844 StringRef OSName = getOSName();
845 // Assume that the OS portion of the triple starts with the canonical name.
846 StringRef OSTypeName = getOSTypeName(getOS());
847 if (OSName.startswith(OSTypeName))
848 OSName = OSName.substr(OSTypeName.size());
850 parseVersionFromName(OSName, Major, Minor, Micro);
853 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
854 unsigned &Micro) const {
855 getOSVersion(Major, Minor, Micro);
858 default: llvm_unreachable("unexpected OS for Darwin triple");
860 // Default to darwin8, i.e., MacOSX 10.4.
863 // Darwin version numbers are skewed from OS X versions.
880 // Ignore the version from the triple. This is only handled because the
881 // the clang driver combines OS X and IOS support into a common Darwin
882 // toolchain that wants to know the OS X version number even when targeting
892 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
893 unsigned &Micro) const {
895 default: llvm_unreachable("unexpected OS for Darwin triple");
898 // Ignore the version from the triple. This is only handled because the
899 // the clang driver combines OS X and IOS support into a common Darwin
900 // toolchain that wants to know the iOS version number even when targeting
907 getOSVersion(Major, Minor, Micro);
908 // Default to 5.0 (or 7.0 for arm64).
910 Major = (getArch() == aarch64) ? 7 : 5;
915 void Triple::setTriple(const Twine &Str) {
919 void Triple::setArch(ArchType Kind) {
920 setArchName(getArchTypeName(Kind));
923 void Triple::setVendor(VendorType Kind) {
924 setVendorName(getVendorTypeName(Kind));
927 void Triple::setOS(OSType Kind) {
928 setOSName(getOSTypeName(Kind));
931 void Triple::setEnvironment(EnvironmentType Kind) {
932 if (ObjectFormat == getDefaultFormat(*this))
933 return setEnvironmentName(getEnvironmentTypeName(Kind));
935 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
936 getObjectFormatTypeName(ObjectFormat)).str());
939 void Triple::setObjectFormat(ObjectFormatType Kind) {
940 if (Environment == UnknownEnvironment)
941 return setEnvironmentName(getObjectFormatTypeName(Kind));
943 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
944 getObjectFormatTypeName(Kind)).str());
947 void Triple::setArchName(StringRef Str) {
948 // Work around a miscompilation bug for Twines in gcc 4.0.3.
949 SmallString<64> Triple;
952 Triple += getVendorName();
954 Triple += getOSAndEnvironmentName();
958 void Triple::setVendorName(StringRef Str) {
959 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
962 void Triple::setOSName(StringRef Str) {
963 if (hasEnvironment())
964 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
965 "-" + getEnvironmentName());
967 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
970 void Triple::setEnvironmentName(StringRef Str) {
971 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
975 void Triple::setOSAndEnvironmentName(StringRef Str) {
976 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
979 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
981 case llvm::Triple::UnknownArch:
984 case llvm::Triple::msp430:
987 case llvm::Triple::arm:
988 case llvm::Triple::armeb:
989 case llvm::Triple::hexagon:
990 case llvm::Triple::le32:
991 case llvm::Triple::mips:
992 case llvm::Triple::mipsel:
993 case llvm::Triple::nvptx:
994 case llvm::Triple::ppc:
995 case llvm::Triple::r600:
996 case llvm::Triple::sparc:
997 case llvm::Triple::sparcel:
998 case llvm::Triple::tce:
999 case llvm::Triple::thumb:
1000 case llvm::Triple::thumbeb:
1001 case llvm::Triple::x86:
1002 case llvm::Triple::xcore:
1003 case llvm::Triple::amdil:
1004 case llvm::Triple::hsail:
1005 case llvm::Triple::spir:
1006 case llvm::Triple::kalimba:
1009 case llvm::Triple::aarch64:
1010 case llvm::Triple::aarch64_be:
1011 case llvm::Triple::amdgcn:
1012 case llvm::Triple::bpf_le:
1013 case llvm::Triple::bpf_be:
1014 case llvm::Triple::le64:
1015 case llvm::Triple::mips64:
1016 case llvm::Triple::mips64el:
1017 case llvm::Triple::nvptx64:
1018 case llvm::Triple::ppc64:
1019 case llvm::Triple::ppc64le:
1020 case llvm::Triple::sparcv9:
1021 case llvm::Triple::systemz:
1022 case llvm::Triple::x86_64:
1023 case llvm::Triple::amdil64:
1024 case llvm::Triple::hsail64:
1025 case llvm::Triple::spir64:
1028 llvm_unreachable("Invalid architecture value");
1031 bool Triple::isArch64Bit() const {
1032 return getArchPointerBitWidth(getArch()) == 64;
1035 bool Triple::isArch32Bit() const {
1036 return getArchPointerBitWidth(getArch()) == 32;
1039 bool Triple::isArch16Bit() const {
1040 return getArchPointerBitWidth(getArch()) == 16;
1043 Triple Triple::get32BitArchVariant() const {
1045 switch (getArch()) {
1046 case Triple::UnknownArch:
1047 case Triple::aarch64:
1048 case Triple::aarch64_be:
1049 case Triple::amdgcn:
1050 case Triple::bpf_le:
1051 case Triple::bpf_be:
1052 case Triple::msp430:
1053 case Triple::systemz:
1054 case Triple::ppc64le:
1055 T.setArch(UnknownArch);
1063 case Triple::hexagon:
1064 case Triple::kalimba:
1067 case Triple::mipsel:
1072 case Triple::sparcel:
1075 case Triple::thumbeb:
1081 case Triple::le64: T.setArch(Triple::le32); break;
1082 case Triple::mips64: T.setArch(Triple::mips); break;
1083 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1084 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1085 case Triple::ppc64: T.setArch(Triple::ppc); break;
1086 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1087 case Triple::x86_64: T.setArch(Triple::x86); break;
1088 case Triple::amdil64: T.setArch(Triple::amdil); break;
1089 case Triple::hsail64: T.setArch(Triple::hsail); break;
1090 case Triple::spir64: T.setArch(Triple::spir); break;
1095 Triple Triple::get64BitArchVariant() const {
1097 switch (getArch()) {
1098 case Triple::UnknownArch:
1101 case Triple::hexagon:
1102 case Triple::kalimba:
1103 case Triple::msp430:
1107 case Triple::thumbeb:
1109 case Triple::sparcel:
1110 T.setArch(UnknownArch);
1113 case Triple::aarch64:
1114 case Triple::aarch64_be:
1115 case Triple::bpf_le:
1116 case Triple::bpf_be:
1118 case Triple::amdil64:
1119 case Triple::amdgcn:
1120 case Triple::hsail64:
1121 case Triple::spir64:
1122 case Triple::mips64:
1123 case Triple::mips64el:
1124 case Triple::nvptx64:
1126 case Triple::ppc64le:
1127 case Triple::sparcv9:
1128 case Triple::systemz:
1129 case Triple::x86_64:
1133 case Triple::le32: T.setArch(Triple::le64); break;
1134 case Triple::mips: T.setArch(Triple::mips64); break;
1135 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1136 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1137 case Triple::ppc: T.setArch(Triple::ppc64); break;
1138 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1139 case Triple::x86: T.setArch(Triple::x86_64); break;
1140 case Triple::amdil: T.setArch(Triple::amdil64); break;
1141 case Triple::hsail: T.setArch(Triple::hsail64); break;
1142 case Triple::spir: T.setArch(Triple::spir64); break;
1147 const char *Triple::getARMCPUForArch(StringRef MArch) const {
1149 MArch = getArchName();
1150 MArch = ARMTargetParser::getCanonicalArchName(MArch);
1152 // Some defaults are forced.
1154 case llvm::Triple::FreeBSD:
1155 case llvm::Triple::NetBSD:
1156 if (!MArch.empty() && MArch == "v6")
1157 return "arm1176jzf-s";
1159 case llvm::Triple::Win32:
1160 // FIXME: this is invalid for WindowsCE
1169 const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
1173 // If no specific architecture version is requested, return the minimum CPU
1174 // required by the OS and environment.
1176 case llvm::Triple::NetBSD:
1177 switch (getEnvironment()) {
1178 case llvm::Triple::GNUEABIHF:
1179 case llvm::Triple::GNUEABI:
1180 case llvm::Triple::EABIHF:
1181 case llvm::Triple::EABI:
1182 return "arm926ej-s";
1186 case llvm::Triple::NaCl:
1189 switch (getEnvironment()) {
1190 case llvm::Triple::EABIHF:
1191 case llvm::Triple::GNUEABIHF:
1192 return "arm1176jzf-s";
1198 llvm_unreachable("invalid arch name");