1 //===--- Triple.cpp - Target triple helper class --------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/Triple.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringSwitch.h"
14 #include "llvm/Support/ErrorHandling.h"
15 #include "llvm/Support/TargetParser.h"
16 #include "llvm/Support/Host.h"
20 const char *Triple::getArchTypeName(ArchType Kind) {
22 case UnknownArch: return "unknown";
24 case aarch64: return "aarch64";
25 case aarch64_be: return "aarch64_be";
26 case arm: return "arm";
27 case armeb: return "armeb";
28 case bpfel: return "bpfel";
29 case bpfeb: return "bpfeb";
30 case hexagon: return "hexagon";
31 case mips: return "mips";
32 case mipsel: return "mipsel";
33 case mips64: return "mips64";
34 case mips64el: return "mips64el";
35 case msp430: return "msp430";
36 case ppc64: return "powerpc64";
37 case ppc64le: return "powerpc64le";
38 case ppc: return "powerpc";
39 case r600: return "r600";
40 case amdgcn: return "amdgcn";
41 case sparc: return "sparc";
42 case sparcv9: return "sparcv9";
43 case sparcel: return "sparcel";
44 case systemz: return "s390x";
45 case tce: return "tce";
46 case thumb: return "thumb";
47 case thumbeb: return "thumbeb";
48 case x86: return "i386";
49 case x86_64: return "x86_64";
50 case xcore: return "xcore";
51 case nvptx: return "nvptx";
52 case nvptx64: return "nvptx64";
53 case le32: return "le32";
54 case le64: return "le64";
55 case amdil: return "amdil";
56 case amdil64: return "amdil64";
57 case hsail: return "hsail";
58 case hsail64: return "hsail64";
59 case spir: return "spir";
60 case spir64: return "spir64";
61 case kalimba: return "kalimba";
62 case shave: return "shave";
63 case wasm32: return "wasm32";
64 case wasm64: return "wasm64";
67 llvm_unreachable("Invalid ArchType!");
70 const char *Triple::getArchTypePrefix(ArchType Kind) {
76 case aarch64_be: return "aarch64";
81 case thumbeb: return "arm";
85 case ppc: return "ppc";
90 case mips64el: return "mips";
92 case hexagon: return "hexagon";
95 case r600: return "amdgpu";
98 case bpfeb: return "bpf";
102 case sparc: return "sparc";
104 case systemz: return "s390";
107 case x86_64: return "x86";
109 case xcore: return "xcore";
111 case nvptx: return "nvptx";
112 case nvptx64: return "nvptx";
114 case le32: return "le32";
115 case le64: return "le64";
118 case amdil64: return "amdil";
121 case hsail64: return "hsail";
124 case spir64: return "spir";
125 case kalimba: return "kalimba";
126 case shave: return "shave";
127 case wasm32: return "wasm32";
128 case wasm64: return "wasm64";
132 const char *Triple::getVendorTypeName(VendorType Kind) {
134 case UnknownVendor: return "unknown";
136 case Apple: return "apple";
137 case PC: return "pc";
138 case SCEI: return "scei";
139 case BGP: return "bgp";
140 case BGQ: return "bgq";
141 case Freescale: return "fsl";
142 case IBM: return "ibm";
143 case ImaginationTechnologies: return "img";
144 case MipsTechnologies: return "mti";
145 case NVIDIA: return "nvidia";
146 case CSR: return "csr";
149 llvm_unreachable("Invalid VendorType!");
152 const char *Triple::getOSTypeName(OSType Kind) {
154 case UnknownOS: return "unknown";
156 case CloudABI: return "cloudabi";
157 case Darwin: return "darwin";
158 case DragonFly: return "dragonfly";
159 case FreeBSD: return "freebsd";
160 case IOS: return "ios";
161 case KFreeBSD: return "kfreebsd";
162 case Linux: return "linux";
163 case Lv2: return "lv2";
164 case MacOSX: return "macosx";
165 case NetBSD: return "netbsd";
166 case OpenBSD: return "openbsd";
167 case Solaris: return "solaris";
168 case Win32: return "windows";
169 case Haiku: return "haiku";
170 case Minix: return "minix";
171 case RTEMS: return "rtems";
172 case NaCl: return "nacl";
173 case CNK: return "cnk";
174 case Bitrig: return "bitrig";
175 case AIX: return "aix";
176 case CUDA: return "cuda";
177 case NVCL: return "nvcl";
178 case AMDHSA: return "amdhsa";
179 case PS4: return "ps4";
182 llvm_unreachable("Invalid OSType");
185 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
187 case UnknownEnvironment: return "unknown";
188 case GNU: return "gnu";
189 case GNUEABIHF: return "gnueabihf";
190 case GNUEABI: return "gnueabi";
191 case GNUX32: return "gnux32";
192 case CODE16: return "code16";
193 case EABI: return "eabi";
194 case EABIHF: return "eabihf";
195 case Android: return "android";
196 case MSVC: return "msvc";
197 case Itanium: return "itanium";
198 case Cygnus: return "cygnus";
201 llvm_unreachable("Invalid EnvironmentType!");
204 static Triple::ArchType parseBPFArch(StringRef ArchName) {
205 if (ArchName.equals("bpf")) {
206 if (sys::IsLittleEndianHost)
207 return Triple::bpfel;
209 return Triple::bpfeb;
210 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
211 return Triple::bpfeb;
212 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
213 return Triple::bpfel;
215 return Triple::UnknownArch;
219 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
220 Triple::ArchType BPFArch(parseBPFArch(Name));
221 return StringSwitch<Triple::ArchType>(Name)
222 .Case("aarch64", aarch64)
223 .Case("aarch64_be", aarch64_be)
224 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
226 .Case("armeb", armeb)
227 .StartsWith("bpf", BPFArch)
229 .Case("mipsel", mipsel)
230 .Case("mips64", mips64)
231 .Case("mips64el", mips64el)
232 .Case("msp430", msp430)
233 .Case("ppc64", ppc64)
236 .Case("ppc64le", ppc64le)
238 .Case("amdgcn", amdgcn)
239 .Case("hexagon", hexagon)
240 .Case("sparc", sparc)
241 .Case("sparcel", sparcel)
242 .Case("sparcv9", sparcv9)
243 .Case("systemz", systemz)
245 .Case("thumb", thumb)
246 .Case("thumbeb", thumbeb)
248 .Case("x86-64", x86_64)
249 .Case("xcore", xcore)
250 .Case("nvptx", nvptx)
251 .Case("nvptx64", nvptx64)
254 .Case("amdil", amdil)
255 .Case("amdil64", amdil64)
256 .Case("hsail", hsail)
257 .Case("hsail64", hsail64)
259 .Case("spir64", spir64)
260 .Case("kalimba", kalimba)
261 .Case("shave", shave)
262 .Case("wasm32", wasm32)
263 .Case("wasm64", wasm64)
264 .Default(UnknownArch);
267 static Triple::ArchType parseARMArch(StringRef ArchName) {
268 unsigned ISA = ARMTargetParser::parseArchISA(ArchName);
269 unsigned ENDIAN = ARMTargetParser::parseArchEndian(ArchName);
271 Triple::ArchType arch = Triple::UnknownArch;
273 case ARM::EK_LITTLE: {
279 arch = Triple::thumb;
281 case ARM::IK_AARCH64:
282 arch = Triple::aarch64;
290 arch = Triple::armeb;
293 arch = Triple::thumbeb;
295 case ARM::IK_AARCH64:
296 arch = Triple::aarch64_be;
303 ArchName = ARMTargetParser::getCanonicalArchName(ArchName);
304 if (ArchName.empty())
305 return Triple::UnknownArch;
307 // Thumb only exists in v4+
308 if (ISA == ARM::IK_THUMB &&
309 (ArchName.startswith("v2") || ArchName.startswith("v3")))
310 return Triple::UnknownArch;
312 // Thumb only for v6m
313 unsigned Profile = ARMTargetParser::parseArchProfile(ArchName);
314 unsigned Version = ARMTargetParser::parseArchVersion(ArchName);
315 if (Profile == ARM::PK_M && Version == 6) {
316 if (ENDIAN == ARM::EK_BIG)
317 return Triple::thumbeb;
319 return Triple::thumb;
325 static Triple::ArchType parseArch(StringRef ArchName) {
326 Triple::ArchType ARMArch(parseARMArch(ArchName));
327 Triple::ArchType BPFArch(parseBPFArch(ArchName));
329 return StringSwitch<Triple::ArchType>(ArchName)
330 .Cases("i386", "i486", "i586", "i686", Triple::x86)
331 // FIXME: Do we need to support these?
332 .Cases("i786", "i886", "i986", Triple::x86)
333 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
334 .Case("powerpc", Triple::ppc)
335 .Cases("powerpc64", "ppu", Triple::ppc64)
336 .Case("powerpc64le", Triple::ppc64le)
337 .Case("xscale", Triple::arm)
338 .Case("xscaleeb", Triple::armeb)
339 .StartsWith("arm", ARMArch)
340 .StartsWith("thumb", ARMArch)
341 .StartsWith("aarch64", ARMArch)
342 .Case("msp430", Triple::msp430)
343 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
344 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
345 .Cases("mips64", "mips64eb", Triple::mips64)
346 .Case("mips64el", Triple::mips64el)
347 .Case("r600", Triple::r600)
348 .Case("amdgcn", Triple::amdgcn)
349 .StartsWith("bpf", BPFArch)
350 .Case("hexagon", Triple::hexagon)
351 .Case("s390x", Triple::systemz)
352 .Case("sparc", Triple::sparc)
353 .Case("sparcel", Triple::sparcel)
354 .Cases("sparcv9", "sparc64", Triple::sparcv9)
355 .Case("tce", Triple::tce)
356 .Case("xcore", Triple::xcore)
357 .Case("nvptx", Triple::nvptx)
358 .Case("nvptx64", Triple::nvptx64)
359 .Case("le32", Triple::le32)
360 .Case("le64", Triple::le64)
361 .Case("amdil", Triple::amdil)
362 .Case("amdil64", Triple::amdil64)
363 .Case("hsail", Triple::hsail)
364 .Case("hsail64", Triple::hsail64)
365 .Case("spir", Triple::spir)
366 .Case("spir64", Triple::spir64)
367 .StartsWith("kalimba", Triple::kalimba)
368 .Case("shave", Triple::shave)
369 .Case("wasm32", Triple::wasm32)
370 .Case("wasm64", Triple::wasm64)
371 .Default(Triple::UnknownArch);
374 static Triple::VendorType parseVendor(StringRef VendorName) {
375 return StringSwitch<Triple::VendorType>(VendorName)
376 .Case("apple", Triple::Apple)
377 .Case("pc", Triple::PC)
378 .Case("scei", Triple::SCEI)
379 .Case("bgp", Triple::BGP)
380 .Case("bgq", Triple::BGQ)
381 .Case("fsl", Triple::Freescale)
382 .Case("ibm", Triple::IBM)
383 .Case("img", Triple::ImaginationTechnologies)
384 .Case("mti", Triple::MipsTechnologies)
385 .Case("nvidia", Triple::NVIDIA)
386 .Case("csr", Triple::CSR)
387 .Default(Triple::UnknownVendor);
390 static Triple::OSType parseOS(StringRef OSName) {
391 return StringSwitch<Triple::OSType>(OSName)
392 .StartsWith("cloudabi", Triple::CloudABI)
393 .StartsWith("darwin", Triple::Darwin)
394 .StartsWith("dragonfly", Triple::DragonFly)
395 .StartsWith("freebsd", Triple::FreeBSD)
396 .StartsWith("ios", Triple::IOS)
397 .StartsWith("kfreebsd", Triple::KFreeBSD)
398 .StartsWith("linux", Triple::Linux)
399 .StartsWith("lv2", Triple::Lv2)
400 .StartsWith("macosx", Triple::MacOSX)
401 .StartsWith("netbsd", Triple::NetBSD)
402 .StartsWith("openbsd", Triple::OpenBSD)
403 .StartsWith("solaris", Triple::Solaris)
404 .StartsWith("win32", Triple::Win32)
405 .StartsWith("windows", Triple::Win32)
406 .StartsWith("haiku", Triple::Haiku)
407 .StartsWith("minix", Triple::Minix)
408 .StartsWith("rtems", Triple::RTEMS)
409 .StartsWith("nacl", Triple::NaCl)
410 .StartsWith("cnk", Triple::CNK)
411 .StartsWith("bitrig", Triple::Bitrig)
412 .StartsWith("aix", Triple::AIX)
413 .StartsWith("cuda", Triple::CUDA)
414 .StartsWith("nvcl", Triple::NVCL)
415 .StartsWith("amdhsa", Triple::AMDHSA)
416 .StartsWith("ps4", Triple::PS4)
417 .Default(Triple::UnknownOS);
420 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
421 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
422 .StartsWith("eabihf", Triple::EABIHF)
423 .StartsWith("eabi", Triple::EABI)
424 .StartsWith("gnueabihf", Triple::GNUEABIHF)
425 .StartsWith("gnueabi", Triple::GNUEABI)
426 .StartsWith("gnux32", Triple::GNUX32)
427 .StartsWith("code16", Triple::CODE16)
428 .StartsWith("gnu", Triple::GNU)
429 .StartsWith("android", Triple::Android)
430 .StartsWith("msvc", Triple::MSVC)
431 .StartsWith("itanium", Triple::Itanium)
432 .StartsWith("cygnus", Triple::Cygnus)
433 .Default(Triple::UnknownEnvironment);
436 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
437 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
438 .EndsWith("coff", Triple::COFF)
439 .EndsWith("elf", Triple::ELF)
440 .EndsWith("macho", Triple::MachO)
441 .Default(Triple::UnknownObjectFormat);
444 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
445 StringRef ARMSubArch = ARMTargetParser::getCanonicalArchName(SubArchName);
447 // For now, this is the small part. Early return.
448 if (ARMSubArch.empty())
449 return StringSwitch<Triple::SubArchType>(SubArchName)
450 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
451 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
452 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
453 .Default(Triple::NoSubArch);
456 switch(ARMTargetParser::parseArch(ARMSubArch)) {
458 return Triple::NoSubArch;
460 return Triple::ARMSubArch_v4t;
464 return Triple::ARMSubArch_v5;
465 case ARM::AK_ARMV5TE:
467 case ARM::AK_IWMMXT2:
469 case ARM::AK_ARMV5TEJ:
470 return Triple::ARMSubArch_v5te;
474 return Triple::ARMSubArch_v6;
476 case ARM::AK_ARMV6ZK:
477 case ARM::AK_ARMV6HL:
478 return Triple::ARMSubArch_v6k;
479 case ARM::AK_ARMV6T2:
480 return Triple::ARMSubArch_v6t2;
482 case ARM::AK_ARMV6SM:
483 return Triple::ARMSubArch_v6m;
488 case ARM::AK_ARMV7HL:
489 return Triple::ARMSubArch_v7;
491 return Triple::ARMSubArch_v7m;
493 return Triple::ARMSubArch_v7s;
494 case ARM::AK_ARMV7EM:
495 return Triple::ARMSubArch_v7em;
497 return Triple::ARMSubArch_v8;
498 case ARM::AK_ARMV8_1A:
499 return Triple::ARMSubArch_v8_1a;
501 return Triple::NoSubArch;
505 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
507 case Triple::UnknownObjectFormat: return "";
508 case Triple::COFF: return "coff";
509 case Triple::ELF: return "elf";
510 case Triple::MachO: return "macho";
512 llvm_unreachable("unknown object format type");
515 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
516 switch (T.getArch()) {
519 case Triple::hexagon:
523 case Triple::mips64el:
527 case Triple::sparcv9:
528 case Triple::systemz:
530 case Triple::ppc64le:
536 return Triple::MachO;
541 return Triple::MachO;
542 else if (T.isOSWindows())
547 /// \brief Construct a triple from the string representation provided.
549 /// This stores the string representation and parses the various pieces into
551 Triple::Triple(const Twine &Str)
553 Arch(parseArch(getArchName())),
554 SubArch(parseSubArch(getArchName())),
555 Vendor(parseVendor(getVendorName())),
556 OS(parseOS(getOSName())),
557 Environment(parseEnvironment(getEnvironmentName())),
558 ObjectFormat(parseFormat(getEnvironmentName())) {
559 if (ObjectFormat == Triple::UnknownObjectFormat)
560 ObjectFormat = getDefaultFormat(*this);
563 /// \brief Construct a triple from string representations of the architecture,
566 /// This joins each argument into a canonical string representation and parses
567 /// them into enum members. It leaves the environment unknown and omits it from
568 /// the string representation.
569 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
570 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
571 Arch(parseArch(ArchStr.str())),
572 SubArch(parseSubArch(ArchStr.str())),
573 Vendor(parseVendor(VendorStr.str())),
574 OS(parseOS(OSStr.str())),
575 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
576 ObjectFormat = getDefaultFormat(*this);
579 /// \brief Construct a triple from string representations of the architecture,
580 /// vendor, OS, and environment.
582 /// This joins each argument into a canonical string representation and parses
583 /// them into enum members.
584 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
585 const Twine &EnvironmentStr)
586 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
587 EnvironmentStr).str()),
588 Arch(parseArch(ArchStr.str())),
589 SubArch(parseSubArch(ArchStr.str())),
590 Vendor(parseVendor(VendorStr.str())),
591 OS(parseOS(OSStr.str())),
592 Environment(parseEnvironment(EnvironmentStr.str())),
593 ObjectFormat(parseFormat(EnvironmentStr.str())) {
594 if (ObjectFormat == Triple::UnknownObjectFormat)
595 ObjectFormat = getDefaultFormat(*this);
598 std::string Triple::normalize(StringRef Str) {
599 bool IsMinGW32 = false;
600 bool IsCygwin = false;
602 // Parse into components.
603 SmallVector<StringRef, 4> Components;
604 Str.split(Components, "-");
606 // If the first component corresponds to a known architecture, preferentially
607 // use it for the architecture. If the second component corresponds to a
608 // known vendor, preferentially use it for the vendor, etc. This avoids silly
609 // component movement when a component parses as (eg) both a valid arch and a
611 ArchType Arch = UnknownArch;
612 if (Components.size() > 0)
613 Arch = parseArch(Components[0]);
614 VendorType Vendor = UnknownVendor;
615 if (Components.size() > 1)
616 Vendor = parseVendor(Components[1]);
617 OSType OS = UnknownOS;
618 if (Components.size() > 2) {
619 OS = parseOS(Components[2]);
620 IsCygwin = Components[2].startswith("cygwin");
621 IsMinGW32 = Components[2].startswith("mingw");
623 EnvironmentType Environment = UnknownEnvironment;
624 if (Components.size() > 3)
625 Environment = parseEnvironment(Components[3]);
626 ObjectFormatType ObjectFormat = UnknownObjectFormat;
627 if (Components.size() > 4)
628 ObjectFormat = parseFormat(Components[4]);
630 // Note which components are already in their final position. These will not
633 Found[0] = Arch != UnknownArch;
634 Found[1] = Vendor != UnknownVendor;
635 Found[2] = OS != UnknownOS;
636 Found[3] = Environment != UnknownEnvironment;
638 // If they are not there already, permute the components into their canonical
639 // positions by seeing if they parse as a valid architecture, and if so moving
640 // the component to the architecture position etc.
641 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
643 continue; // Already in the canonical position.
645 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
646 // Do not reparse any components that already matched.
647 if (Idx < array_lengthof(Found) && Found[Idx])
650 // Does this component parse as valid for the target position?
652 StringRef Comp = Components[Idx];
654 default: llvm_unreachable("unexpected component type!");
656 Arch = parseArch(Comp);
657 Valid = Arch != UnknownArch;
660 Vendor = parseVendor(Comp);
661 Valid = Vendor != UnknownVendor;
665 IsCygwin = Comp.startswith("cygwin");
666 IsMinGW32 = Comp.startswith("mingw");
667 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
670 Environment = parseEnvironment(Comp);
671 Valid = Environment != UnknownEnvironment;
673 ObjectFormat = parseFormat(Comp);
674 Valid = ObjectFormat != UnknownObjectFormat;
679 continue; // Nope, try the next component.
681 // Move the component to the target position, pushing any non-fixed
682 // components that are in the way to the right. This tends to give
683 // good results in the common cases of a forgotten vendor component
684 // or a wrongly positioned environment.
686 // Insert left, pushing the existing components to the right. For
687 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
688 StringRef CurrentComponent(""); // The empty component.
689 // Replace the component we are moving with an empty component.
690 std::swap(CurrentComponent, Components[Idx]);
691 // Insert the component being moved at Pos, displacing any existing
692 // components to the right.
693 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
694 // Skip over any fixed components.
695 while (i < array_lengthof(Found) && Found[i])
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]);
701 } else if (Pos > Idx) {
702 // Push right by inserting empty components until the component at Idx
703 // reaches the target position Pos. For example, pc-a -> -pc-a when
704 // moving pc to the second position.
706 // Insert one empty component at Idx.
707 StringRef CurrentComponent(""); // The empty component.
708 for (unsigned i = Idx; i < Components.size();) {
709 // Place the component at the new position, getting the component
710 // that was at this position - it will be moved right.
711 std::swap(CurrentComponent, Components[i]);
712 // If it was placed on top of an empty component then we are done.
713 if (CurrentComponent.empty())
715 // Advance to the next component, skipping any fixed components.
716 while (++i < array_lengthof(Found) && Found[i])
719 // The last component was pushed off the end - append it.
720 if (!CurrentComponent.empty())
721 Components.push_back(CurrentComponent);
723 // Advance Idx to the component's new position.
724 while (++Idx < array_lengthof(Found) && Found[Idx])
726 } while (Idx < Pos); // Add more until the final position is reached.
728 assert(Pos < Components.size() && Components[Pos] == Comp &&
729 "Component moved wrong!");
735 // Special case logic goes here. At this point Arch, Vendor and OS have the
736 // correct values for the computed components.
737 std::string NormalizedEnvironment;
738 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
739 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
740 if (AndroidVersion.empty()) {
741 Components[3] = "android";
743 NormalizedEnvironment = Twine("android", AndroidVersion).str();
744 Components[3] = NormalizedEnvironment;
748 if (OS == Triple::Win32) {
749 Components.resize(4);
750 Components[2] = "windows";
751 if (Environment == UnknownEnvironment) {
752 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
753 Components[3] = "msvc";
755 Components[3] = getObjectFormatTypeName(ObjectFormat);
757 } else if (IsMinGW32) {
758 Components.resize(4);
759 Components[2] = "windows";
760 Components[3] = "gnu";
761 } else if (IsCygwin) {
762 Components.resize(4);
763 Components[2] = "windows";
764 Components[3] = "cygnus";
766 if (IsMinGW32 || IsCygwin ||
767 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
768 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
769 Components.resize(5);
770 Components[4] = getObjectFormatTypeName(ObjectFormat);
774 // Stick the corrected components back together to form the normalized string.
775 std::string Normalized;
776 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
777 if (i) Normalized += '-';
778 Normalized += Components[i];
783 StringRef Triple::getArchName() const {
784 return StringRef(Data).split('-').first; // Isolate first component
787 StringRef Triple::getVendorName() const {
788 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
789 return Tmp.split('-').first; // Isolate second component
792 StringRef Triple::getOSName() const {
793 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
794 Tmp = Tmp.split('-').second; // Strip second component
795 return Tmp.split('-').first; // Isolate third component
798 StringRef Triple::getEnvironmentName() const {
799 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
800 Tmp = Tmp.split('-').second; // Strip second component
801 return Tmp.split('-').second; // Strip third component
804 StringRef Triple::getOSAndEnvironmentName() const {
805 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
806 return Tmp.split('-').second; // Strip second component
809 static unsigned EatNumber(StringRef &Str) {
810 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
814 // Consume the leading digit.
815 Result = Result*10 + (Str[0] - '0');
819 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
824 static void parseVersionFromName(StringRef Name, unsigned &Major,
825 unsigned &Minor, unsigned &Micro) {
826 // Any unset version defaults to 0.
827 Major = Minor = Micro = 0;
829 // Parse up to three components.
830 unsigned *Components[3] = {&Major, &Minor, &Micro};
831 for (unsigned i = 0; i != 3; ++i) {
832 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
835 // Consume the leading number.
836 *Components[i] = EatNumber(Name);
838 // Consume the separator, if present.
839 if (Name.startswith("."))
840 Name = Name.substr(1);
844 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
845 unsigned &Micro) const {
846 StringRef EnvironmentName = getEnvironmentName();
847 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
848 if (EnvironmentName.startswith(EnvironmentTypeName))
849 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
851 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
854 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
855 unsigned &Micro) const {
856 StringRef OSName = getOSName();
857 // Assume that the OS portion of the triple starts with the canonical name.
858 StringRef OSTypeName = getOSTypeName(getOS());
859 if (OSName.startswith(OSTypeName))
860 OSName = OSName.substr(OSTypeName.size());
862 parseVersionFromName(OSName, Major, Minor, Micro);
865 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
866 unsigned &Micro) const {
867 getOSVersion(Major, Minor, Micro);
870 default: llvm_unreachable("unexpected OS for Darwin triple");
872 // Default to darwin8, i.e., MacOSX 10.4.
875 // Darwin version numbers are skewed from OS X versions.
892 // Ignore the version from the triple. This is only handled because the
893 // the clang driver combines OS X and IOS support into a common Darwin
894 // toolchain that wants to know the OS X version number even when targeting
904 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
905 unsigned &Micro) const {
907 default: llvm_unreachable("unexpected OS for Darwin triple");
910 // Ignore the version from the triple. This is only handled because the
911 // the clang driver combines OS X and IOS support into a common Darwin
912 // toolchain that wants to know the iOS version number even when targeting
919 getOSVersion(Major, Minor, Micro);
920 // Default to 5.0 (or 7.0 for arm64).
922 Major = (getArch() == aarch64) ? 7 : 5;
927 void Triple::setTriple(const Twine &Str) {
931 void Triple::setArch(ArchType Kind) {
932 setArchName(getArchTypeName(Kind));
935 void Triple::setVendor(VendorType Kind) {
936 setVendorName(getVendorTypeName(Kind));
939 void Triple::setOS(OSType Kind) {
940 setOSName(getOSTypeName(Kind));
943 void Triple::setEnvironment(EnvironmentType Kind) {
944 if (ObjectFormat == getDefaultFormat(*this))
945 return setEnvironmentName(getEnvironmentTypeName(Kind));
947 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
948 getObjectFormatTypeName(ObjectFormat)).str());
951 void Triple::setObjectFormat(ObjectFormatType Kind) {
952 if (Environment == UnknownEnvironment)
953 return setEnvironmentName(getObjectFormatTypeName(Kind));
955 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
956 getObjectFormatTypeName(Kind)).str());
959 void Triple::setArchName(StringRef Str) {
960 // Work around a miscompilation bug for Twines in gcc 4.0.3.
961 SmallString<64> Triple;
964 Triple += getVendorName();
966 Triple += getOSAndEnvironmentName();
970 void Triple::setVendorName(StringRef Str) {
971 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
974 void Triple::setOSName(StringRef Str) {
975 if (hasEnvironment())
976 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
977 "-" + getEnvironmentName());
979 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
982 void Triple::setEnvironmentName(StringRef Str) {
983 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
987 void Triple::setOSAndEnvironmentName(StringRef Str) {
988 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
991 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
993 case llvm::Triple::UnknownArch:
996 case llvm::Triple::msp430:
999 case llvm::Triple::arm:
1000 case llvm::Triple::armeb:
1001 case llvm::Triple::hexagon:
1002 case llvm::Triple::le32:
1003 case llvm::Triple::mips:
1004 case llvm::Triple::mipsel:
1005 case llvm::Triple::nvptx:
1006 case llvm::Triple::ppc:
1007 case llvm::Triple::r600:
1008 case llvm::Triple::sparc:
1009 case llvm::Triple::sparcel:
1010 case llvm::Triple::tce:
1011 case llvm::Triple::thumb:
1012 case llvm::Triple::thumbeb:
1013 case llvm::Triple::x86:
1014 case llvm::Triple::xcore:
1015 case llvm::Triple::amdil:
1016 case llvm::Triple::hsail:
1017 case llvm::Triple::spir:
1018 case llvm::Triple::kalimba:
1019 case llvm::Triple::shave:
1020 case llvm::Triple::wasm32:
1023 case llvm::Triple::aarch64:
1024 case llvm::Triple::aarch64_be:
1025 case llvm::Triple::amdgcn:
1026 case llvm::Triple::bpfel:
1027 case llvm::Triple::bpfeb:
1028 case llvm::Triple::le64:
1029 case llvm::Triple::mips64:
1030 case llvm::Triple::mips64el:
1031 case llvm::Triple::nvptx64:
1032 case llvm::Triple::ppc64:
1033 case llvm::Triple::ppc64le:
1034 case llvm::Triple::sparcv9:
1035 case llvm::Triple::systemz:
1036 case llvm::Triple::x86_64:
1037 case llvm::Triple::amdil64:
1038 case llvm::Triple::hsail64:
1039 case llvm::Triple::spir64:
1040 case llvm::Triple::wasm64:
1043 llvm_unreachable("Invalid architecture value");
1046 bool Triple::isArch64Bit() const {
1047 return getArchPointerBitWidth(getArch()) == 64;
1050 bool Triple::isArch32Bit() const {
1051 return getArchPointerBitWidth(getArch()) == 32;
1054 bool Triple::isArch16Bit() const {
1055 return getArchPointerBitWidth(getArch()) == 16;
1058 Triple Triple::get32BitArchVariant() const {
1060 switch (getArch()) {
1061 case Triple::UnknownArch:
1062 case Triple::aarch64:
1063 case Triple::aarch64_be:
1064 case Triple::amdgcn:
1067 case Triple::msp430:
1068 case Triple::systemz:
1069 case Triple::ppc64le:
1070 T.setArch(UnknownArch);
1078 case Triple::hexagon:
1079 case Triple::kalimba:
1082 case Triple::mipsel:
1087 case Triple::sparcel:
1090 case Triple::thumbeb:
1094 case Triple::wasm32:
1098 case Triple::le64: T.setArch(Triple::le32); break;
1099 case Triple::mips64: T.setArch(Triple::mips); break;
1100 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1101 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1102 case Triple::ppc64: T.setArch(Triple::ppc); break;
1103 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1104 case Triple::x86_64: T.setArch(Triple::x86); break;
1105 case Triple::amdil64: T.setArch(Triple::amdil); break;
1106 case Triple::hsail64: T.setArch(Triple::hsail); break;
1107 case Triple::spir64: T.setArch(Triple::spir); break;
1108 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1113 Triple Triple::get64BitArchVariant() const {
1115 switch (getArch()) {
1116 case Triple::UnknownArch:
1119 case Triple::hexagon:
1120 case Triple::kalimba:
1121 case Triple::msp430:
1125 case Triple::thumbeb:
1127 case Triple::sparcel:
1129 T.setArch(UnknownArch);
1132 case Triple::aarch64:
1133 case Triple::aarch64_be:
1137 case Triple::amdil64:
1138 case Triple::amdgcn:
1139 case Triple::hsail64:
1140 case Triple::spir64:
1141 case Triple::mips64:
1142 case Triple::mips64el:
1143 case Triple::nvptx64:
1145 case Triple::ppc64le:
1146 case Triple::sparcv9:
1147 case Triple::systemz:
1148 case Triple::x86_64:
1149 case Triple::wasm64:
1153 case Triple::le32: T.setArch(Triple::le64); break;
1154 case Triple::mips: T.setArch(Triple::mips64); break;
1155 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1156 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1157 case Triple::ppc: T.setArch(Triple::ppc64); break;
1158 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1159 case Triple::x86: T.setArch(Triple::x86_64); break;
1160 case Triple::amdil: T.setArch(Triple::amdil64); break;
1161 case Triple::hsail: T.setArch(Triple::hsail64); break;
1162 case Triple::spir: T.setArch(Triple::spir64); break;
1163 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1168 const char *Triple::getARMCPUForArch(StringRef MArch) const {
1170 MArch = getArchName();
1171 MArch = ARMTargetParser::getCanonicalArchName(MArch);
1173 // Some defaults are forced.
1175 case llvm::Triple::FreeBSD:
1176 case llvm::Triple::NetBSD:
1177 if (!MArch.empty() && MArch == "v6")
1178 return "arm1176jzf-s";
1180 case llvm::Triple::Win32:
1181 // FIXME: this is invalid for WindowsCE
1190 const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
1194 // If no specific architecture version is requested, return the minimum CPU
1195 // required by the OS and environment.
1197 case llvm::Triple::NetBSD:
1198 switch (getEnvironment()) {
1199 case llvm::Triple::GNUEABIHF:
1200 case llvm::Triple::GNUEABI:
1201 case llvm::Triple::EABIHF:
1202 case llvm::Triple::EABI:
1203 return "arm926ej-s";
1207 case llvm::Triple::NaCl:
1210 switch (getEnvironment()) {
1211 case llvm::Triple::EABIHF:
1212 case llvm::Triple::GNUEABIHF:
1213 return "arm1176jzf-s";
1219 llvm_unreachable("invalid arch name");