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"
18 const char *Triple::getArchTypeName(ArchType Kind) {
20 case UnknownArch: return "unknown";
22 case aarch64: return "aarch64";
23 case aarch64_be: return "aarch64_be";
24 case arm: return "arm";
25 case armeb: return "armeb";
26 case hexagon: return "hexagon";
27 case mips: return "mips";
28 case mipsel: return "mipsel";
29 case mips64: return "mips64";
30 case mips64el: return "mips64el";
31 case msp430: return "msp430";
32 case ppc64: return "powerpc64";
33 case ppc64le: return "powerpc64le";
34 case ppc: return "powerpc";
35 case r600: return "r600";
36 case sparc: return "sparc";
37 case sparcv9: return "sparcv9";
38 case systemz: return "s390x";
39 case tce: return "tce";
40 case thumb: return "thumb";
41 case thumbeb: return "thumbeb";
42 case x86: return "i386";
43 case x86_64: return "x86_64";
44 case xcore: return "xcore";
45 case nvptx: return "nvptx";
46 case nvptx64: return "nvptx64";
47 case le32: return "le32";
48 case amdil: return "amdil";
49 case spir: return "spir";
50 case spir64: return "spir64";
51 case kalimba: return "kalimba";
54 llvm_unreachable("Invalid ArchType!");
57 const char *Triple::getArchTypePrefix(ArchType Kind) {
63 case aarch64_be: return "aarch64";
68 case thumbeb: return "arm";
72 case ppc: return "ppc";
77 case mips64el: return "mips";
79 case hexagon: return "hexagon";
81 case r600: return "r600";
84 case sparc: return "sparc";
86 case systemz: return "systemz";
89 case x86_64: return "x86";
91 case xcore: return "xcore";
93 case nvptx: return "nvptx";
94 case nvptx64: return "nvptx";
96 case le32: return "le32";
97 case amdil: return "amdil";
98 case spir: return "spir";
99 case spir64: return "spir";
100 case kalimba: return "kalimba";
104 const char *Triple::getVendorTypeName(VendorType Kind) {
106 case UnknownVendor: return "unknown";
108 case Apple: return "apple";
109 case PC: return "pc";
110 case SCEI: return "scei";
111 case BGP: return "bgp";
112 case BGQ: return "bgq";
113 case Freescale: return "fsl";
114 case IBM: return "ibm";
115 case ImaginationTechnologies: return "img";
116 case MipsTechnologies: return "mti";
117 case NVIDIA: return "nvidia";
118 case CSR: return "csr";
121 llvm_unreachable("Invalid VendorType!");
124 const char *Triple::getOSTypeName(OSType Kind) {
126 case UnknownOS: return "unknown";
128 case AuroraUX: return "auroraux";
129 case Darwin: return "darwin";
130 case DragonFly: return "dragonfly";
131 case FreeBSD: return "freebsd";
132 case IOS: return "ios";
133 case KFreeBSD: return "kfreebsd";
134 case Linux: return "linux";
135 case Lv2: return "lv2";
136 case MacOSX: return "macosx";
137 case NetBSD: return "netbsd";
138 case OpenBSD: return "openbsd";
139 case Solaris: return "solaris";
140 case Win32: return "windows";
141 case Haiku: return "haiku";
142 case Minix: return "minix";
143 case RTEMS: return "rtems";
144 case NaCl: return "nacl";
145 case CNK: return "cnk";
146 case Bitrig: return "bitrig";
147 case AIX: return "aix";
148 case CUDA: return "cuda";
149 case NVCL: return "nvcl";
152 llvm_unreachable("Invalid OSType");
155 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
157 case UnknownEnvironment: return "unknown";
158 case GNU: return "gnu";
159 case GNUEABIHF: return "gnueabihf";
160 case GNUEABI: return "gnueabi";
161 case GNUX32: return "gnux32";
162 case CODE16: return "code16";
163 case EABI: return "eabi";
164 case EABIHF: return "eabihf";
165 case Android: return "android";
166 case MSVC: return "msvc";
167 case Itanium: return "itanium";
168 case Cygnus: return "cygnus";
171 llvm_unreachable("Invalid EnvironmentType!");
174 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
175 return StringSwitch<Triple::ArchType>(Name)
176 .Case("aarch64", aarch64)
177 .Case("aarch64_be", aarch64_be)
178 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
180 .Case("armeb", armeb)
182 .Case("mipsel", mipsel)
183 .Case("mips64", mips64)
184 .Case("mips64el", mips64el)
185 .Case("msp430", msp430)
186 .Case("ppc64", ppc64)
189 .Case("ppc64le", ppc64le)
191 .Case("hexagon", hexagon)
192 .Case("sparc", sparc)
193 .Case("sparcv9", sparcv9)
194 .Case("systemz", systemz)
196 .Case("thumb", thumb)
197 .Case("thumbeb", thumbeb)
199 .Case("x86-64", x86_64)
200 .Case("xcore", xcore)
201 .Case("nvptx", nvptx)
202 .Case("nvptx64", nvptx64)
204 .Case("amdil", amdil)
206 .Case("spir64", spir64)
207 .Case("kalimba", kalimba)
208 .Default(UnknownArch);
211 static Triple::ArchType parseArch(StringRef ArchName) {
212 return StringSwitch<Triple::ArchType>(ArchName)
213 .Cases("i386", "i486", "i586", "i686", Triple::x86)
214 // FIXME: Do we need to support these?
215 .Cases("i786", "i886", "i986", Triple::x86)
216 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
217 .Case("powerpc", Triple::ppc)
218 .Cases("powerpc64", "ppu", Triple::ppc64)
219 .Case("powerpc64le", Triple::ppc64le)
220 .Case("aarch64", Triple::aarch64)
221 .Case("aarch64_be", Triple::aarch64_be)
222 .Case("arm64", Triple::aarch64)
223 .Cases("arm", "xscale", Triple::arm)
224 // FIXME: It would be good to replace these with explicit names for all the
225 // various suffixes supported.
226 .StartsWith("armv", Triple::arm)
227 .Case("armeb", Triple::armeb)
228 .StartsWith("armebv", Triple::armeb)
229 .Case("thumb", Triple::thumb)
230 .StartsWith("thumbv", Triple::thumb)
231 .Case("thumbeb", Triple::thumbeb)
232 .StartsWith("thumbebv", Triple::thumbeb)
233 .Case("msp430", Triple::msp430)
234 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
235 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
236 .Cases("mips64", "mips64eb", Triple::mips64)
237 .Case("mips64el", Triple::mips64el)
238 .Case("r600", Triple::r600)
239 .Case("hexagon", Triple::hexagon)
240 .Case("s390x", Triple::systemz)
241 .Case("sparc", Triple::sparc)
242 .Cases("sparcv9", "sparc64", Triple::sparcv9)
243 .Case("tce", Triple::tce)
244 .Case("xcore", Triple::xcore)
245 .Case("nvptx", Triple::nvptx)
246 .Case("nvptx64", Triple::nvptx64)
247 .Case("le32", Triple::le32)
248 .Case("amdil", Triple::amdil)
249 .Case("spir", Triple::spir)
250 .Case("spir64", Triple::spir64)
251 .Case("kalimba", Triple::kalimba)
252 .Default(Triple::UnknownArch);
255 static Triple::VendorType parseVendor(StringRef VendorName) {
256 return StringSwitch<Triple::VendorType>(VendorName)
257 .Case("apple", Triple::Apple)
258 .Case("pc", Triple::PC)
259 .Case("scei", Triple::SCEI)
260 .Case("bgp", Triple::BGP)
261 .Case("bgq", Triple::BGQ)
262 .Case("fsl", Triple::Freescale)
263 .Case("ibm", Triple::IBM)
264 .Case("img", Triple::ImaginationTechnologies)
265 .Case("mti", Triple::MipsTechnologies)
266 .Case("nvidia", Triple::NVIDIA)
267 .Case("csr", Triple::CSR)
268 .Default(Triple::UnknownVendor);
271 static Triple::OSType parseOS(StringRef OSName) {
272 return StringSwitch<Triple::OSType>(OSName)
273 .StartsWith("auroraux", Triple::AuroraUX)
274 .StartsWith("darwin", Triple::Darwin)
275 .StartsWith("dragonfly", Triple::DragonFly)
276 .StartsWith("freebsd", Triple::FreeBSD)
277 .StartsWith("ios", Triple::IOS)
278 .StartsWith("kfreebsd", Triple::KFreeBSD)
279 .StartsWith("linux", Triple::Linux)
280 .StartsWith("lv2", Triple::Lv2)
281 .StartsWith("macosx", Triple::MacOSX)
282 .StartsWith("netbsd", Triple::NetBSD)
283 .StartsWith("openbsd", Triple::OpenBSD)
284 .StartsWith("solaris", Triple::Solaris)
285 .StartsWith("win32", Triple::Win32)
286 .StartsWith("windows", Triple::Win32)
287 .StartsWith("haiku", Triple::Haiku)
288 .StartsWith("minix", Triple::Minix)
289 .StartsWith("rtems", Triple::RTEMS)
290 .StartsWith("nacl", Triple::NaCl)
291 .StartsWith("cnk", Triple::CNK)
292 .StartsWith("bitrig", Triple::Bitrig)
293 .StartsWith("aix", Triple::AIX)
294 .StartsWith("cuda", Triple::CUDA)
295 .StartsWith("nvcl", Triple::NVCL)
296 .Default(Triple::UnknownOS);
299 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
300 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
301 .StartsWith("eabihf", Triple::EABIHF)
302 .StartsWith("eabi", Triple::EABI)
303 .StartsWith("gnueabihf", Triple::GNUEABIHF)
304 .StartsWith("gnueabi", Triple::GNUEABI)
305 .StartsWith("gnux32", Triple::GNUX32)
306 .StartsWith("code16", Triple::CODE16)
307 .StartsWith("gnu", Triple::GNU)
308 .StartsWith("android", Triple::Android)
309 .StartsWith("msvc", Triple::MSVC)
310 .StartsWith("itanium", Triple::Itanium)
311 .StartsWith("cygnus", Triple::Cygnus)
312 .Default(Triple::UnknownEnvironment);
315 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
316 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
317 .EndsWith("coff", Triple::COFF)
318 .EndsWith("elf", Triple::ELF)
319 .EndsWith("macho", Triple::MachO)
320 .Default(Triple::UnknownObjectFormat);
323 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
324 return StringSwitch<Triple::SubArchType>(SubArchName)
325 .EndsWith("v8", Triple::ARMSubArch_v8)
326 .EndsWith("v8a", Triple::ARMSubArch_v8)
327 .EndsWith("v7", Triple::ARMSubArch_v7)
328 .EndsWith("v7a", Triple::ARMSubArch_v7)
329 .EndsWith("v7em", Triple::ARMSubArch_v7em)
330 .EndsWith("v7l", Triple::ARMSubArch_v7)
331 .EndsWith("v7m", Triple::ARMSubArch_v7m)
332 .EndsWith("v7r", Triple::ARMSubArch_v7)
333 .EndsWith("v7s", Triple::ARMSubArch_v7s)
334 .EndsWith("v6", Triple::ARMSubArch_v6)
335 .EndsWith("v6m", Triple::ARMSubArch_v6m)
336 .EndsWith("v6t2", Triple::ARMSubArch_v6t2)
337 .EndsWith("v5", Triple::ARMSubArch_v5)
338 .EndsWith("v5e", Triple::ARMSubArch_v5)
339 .EndsWith("v5t", Triple::ARMSubArch_v5)
340 .EndsWith("v5te", Triple::ARMSubArch_v5te)
341 .EndsWith("v4t", Triple::ARMSubArch_v4t)
342 .Default(Triple::NoSubArch);
345 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
347 case Triple::UnknownObjectFormat: return "";
348 case Triple::COFF: return "coff";
349 case Triple::ELF: return "elf";
350 case Triple::MachO: return "macho";
352 llvm_unreachable("unknown object format type");
355 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
357 return Triple::MachO;
358 else if (T.isOSWindows())
363 /// \brief Construct a triple from the string representation provided.
365 /// This stores the string representation and parses the various pieces into
367 Triple::Triple(const Twine &Str)
369 Arch(parseArch(getArchName())),
370 SubArch(parseSubArch(getArchName())),
371 Vendor(parseVendor(getVendorName())),
372 OS(parseOS(getOSName())),
373 Environment(parseEnvironment(getEnvironmentName())),
374 ObjectFormat(parseFormat(getEnvironmentName())) {
375 if (ObjectFormat == Triple::UnknownObjectFormat)
376 ObjectFormat = getDefaultFormat(*this);
379 /// \brief Construct a triple from string representations of the architecture,
382 /// This joins each argument into a canonical string representation and parses
383 /// them into enum members. It leaves the environment unknown and omits it from
384 /// the string representation.
385 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
386 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
387 Arch(parseArch(ArchStr.str())),
388 SubArch(parseSubArch(ArchStr.str())),
389 Vendor(parseVendor(VendorStr.str())),
390 OS(parseOS(OSStr.str())),
391 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
392 ObjectFormat = getDefaultFormat(*this);
395 /// \brief Construct a triple from string representations of the architecture,
396 /// vendor, OS, and environment.
398 /// This joins each argument into a canonical string representation and parses
399 /// them into enum members.
400 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
401 const Twine &EnvironmentStr)
402 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
403 EnvironmentStr).str()),
404 Arch(parseArch(ArchStr.str())),
405 SubArch(parseSubArch(ArchStr.str())),
406 Vendor(parseVendor(VendorStr.str())),
407 OS(parseOS(OSStr.str())),
408 Environment(parseEnvironment(EnvironmentStr.str())),
409 ObjectFormat(parseFormat(EnvironmentStr.str())) {
410 if (ObjectFormat == Triple::UnknownObjectFormat)
411 ObjectFormat = getDefaultFormat(*this);
414 std::string Triple::normalize(StringRef Str) {
415 bool IsMinGW32 = false;
416 bool IsCygwin = false;
418 // Parse into components.
419 SmallVector<StringRef, 4> Components;
420 Str.split(Components, "-");
422 // If the first component corresponds to a known architecture, preferentially
423 // use it for the architecture. If the second component corresponds to a
424 // known vendor, preferentially use it for the vendor, etc. This avoids silly
425 // component movement when a component parses as (eg) both a valid arch and a
427 ArchType Arch = UnknownArch;
428 if (Components.size() > 0)
429 Arch = parseArch(Components[0]);
430 VendorType Vendor = UnknownVendor;
431 if (Components.size() > 1)
432 Vendor = parseVendor(Components[1]);
433 OSType OS = UnknownOS;
434 if (Components.size() > 2) {
435 OS = parseOS(Components[2]);
436 IsCygwin = Components[2].startswith("cygwin");
437 IsMinGW32 = Components[2].startswith("mingw");
439 EnvironmentType Environment = UnknownEnvironment;
440 if (Components.size() > 3)
441 Environment = parseEnvironment(Components[3]);
442 ObjectFormatType ObjectFormat = UnknownObjectFormat;
443 if (Components.size() > 4)
444 ObjectFormat = parseFormat(Components[4]);
446 // Note which components are already in their final position. These will not
449 Found[0] = Arch != UnknownArch;
450 Found[1] = Vendor != UnknownVendor;
451 Found[2] = OS != UnknownOS;
452 Found[3] = Environment != UnknownEnvironment;
454 // If they are not there already, permute the components into their canonical
455 // positions by seeing if they parse as a valid architecture, and if so moving
456 // the component to the architecture position etc.
457 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
459 continue; // Already in the canonical position.
461 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
462 // Do not reparse any components that already matched.
463 if (Idx < array_lengthof(Found) && Found[Idx])
466 // Does this component parse as valid for the target position?
468 StringRef Comp = Components[Idx];
470 default: llvm_unreachable("unexpected component type!");
472 Arch = parseArch(Comp);
473 Valid = Arch != UnknownArch;
476 Vendor = parseVendor(Comp);
477 Valid = Vendor != UnknownVendor;
481 IsCygwin = Comp.startswith("cygwin");
482 IsMinGW32 = Comp.startswith("mingw");
483 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
486 Environment = parseEnvironment(Comp);
487 Valid = Environment != UnknownEnvironment;
489 ObjectFormat = parseFormat(Comp);
490 Valid = ObjectFormat != UnknownObjectFormat;
495 continue; // Nope, try the next component.
497 // Move the component to the target position, pushing any non-fixed
498 // components that are in the way to the right. This tends to give
499 // good results in the common cases of a forgotten vendor component
500 // or a wrongly positioned environment.
502 // Insert left, pushing the existing components to the right. For
503 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
504 StringRef CurrentComponent(""); // The empty component.
505 // Replace the component we are moving with an empty component.
506 std::swap(CurrentComponent, Components[Idx]);
507 // Insert the component being moved at Pos, displacing any existing
508 // components to the right.
509 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
510 // Skip over any fixed components.
511 while (i < array_lengthof(Found) && Found[i])
513 // Place the component at the new position, getting the component
514 // that was at this position - it will be moved right.
515 std::swap(CurrentComponent, Components[i]);
517 } else if (Pos > Idx) {
518 // Push right by inserting empty components until the component at Idx
519 // reaches the target position Pos. For example, pc-a -> -pc-a when
520 // moving pc to the second position.
522 // Insert one empty component at Idx.
523 StringRef CurrentComponent(""); // The empty component.
524 for (unsigned i = Idx; i < Components.size();) {
525 // Place the component at the new position, getting the component
526 // that was at this position - it will be moved right.
527 std::swap(CurrentComponent, Components[i]);
528 // If it was placed on top of an empty component then we are done.
529 if (CurrentComponent.empty())
531 // Advance to the next component, skipping any fixed components.
532 while (++i < array_lengthof(Found) && Found[i])
535 // The last component was pushed off the end - append it.
536 if (!CurrentComponent.empty())
537 Components.push_back(CurrentComponent);
539 // Advance Idx to the component's new position.
540 while (++Idx < array_lengthof(Found) && Found[Idx])
542 } while (Idx < Pos); // Add more until the final position is reached.
544 assert(Pos < Components.size() && Components[Pos] == Comp &&
545 "Component moved wrong!");
551 // Special case logic goes here. At this point Arch, Vendor and OS have the
552 // correct values for the computed components.
554 if (OS == Triple::Win32) {
555 Components.resize(4);
556 Components[2] = "windows";
557 if (Environment == UnknownEnvironment) {
558 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
559 Components[3] = "msvc";
561 Components[3] = getObjectFormatTypeName(ObjectFormat);
563 } else if (IsMinGW32) {
564 Components.resize(4);
565 Components[2] = "windows";
566 Components[3] = "gnu";
567 } else if (IsCygwin) {
568 Components.resize(4);
569 Components[2] = "windows";
570 Components[3] = "cygnus";
572 if (IsMinGW32 || IsCygwin ||
573 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
574 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
575 Components.resize(5);
576 Components[4] = getObjectFormatTypeName(ObjectFormat);
580 // Stick the corrected components back together to form the normalized string.
581 std::string Normalized;
582 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
583 if (i) Normalized += '-';
584 Normalized += Components[i];
589 StringRef Triple::getArchName() const {
590 return StringRef(Data).split('-').first; // Isolate first component
593 StringRef Triple::getVendorName() const {
594 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
595 return Tmp.split('-').first; // Isolate second component
598 StringRef Triple::getOSName() const {
599 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
600 Tmp = Tmp.split('-').second; // Strip second component
601 return Tmp.split('-').first; // Isolate third component
604 StringRef Triple::getEnvironmentName() const {
605 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
606 Tmp = Tmp.split('-').second; // Strip second component
607 return Tmp.split('-').second; // Strip third component
610 StringRef Triple::getOSAndEnvironmentName() const {
611 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
612 return Tmp.split('-').second; // Strip second component
615 static unsigned EatNumber(StringRef &Str) {
616 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
620 // Consume the leading digit.
621 Result = Result*10 + (Str[0] - '0');
625 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
630 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
631 unsigned &Micro) const {
632 StringRef OSName = getOSName();
634 // Assume that the OS portion of the triple starts with the canonical name.
635 StringRef OSTypeName = getOSTypeName(getOS());
636 if (OSName.startswith(OSTypeName))
637 OSName = OSName.substr(OSTypeName.size());
639 // Any unset version defaults to 0.
640 Major = Minor = Micro = 0;
642 // Parse up to three components.
643 unsigned *Components[3] = { &Major, &Minor, &Micro };
644 for (unsigned i = 0; i != 3; ++i) {
645 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
648 // Consume the leading number.
649 *Components[i] = EatNumber(OSName);
651 // Consume the separator, if present.
652 if (OSName.startswith("."))
653 OSName = OSName.substr(1);
657 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
658 unsigned &Micro) const {
659 getOSVersion(Major, Minor, Micro);
662 default: llvm_unreachable("unexpected OS for Darwin triple");
664 // Default to darwin8, i.e., MacOSX 10.4.
667 // Darwin version numbers are skewed from OS X versions.
684 // Ignore the version from the triple. This is only handled because the
685 // the clang driver combines OS X and IOS support into a common Darwin
686 // toolchain that wants to know the OS X version number even when targeting
696 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
697 unsigned &Micro) const {
699 default: llvm_unreachable("unexpected OS for Darwin triple");
702 // Ignore the version from the triple. This is only handled because the
703 // the clang driver combines OS X and IOS support into a common Darwin
704 // toolchain that wants to know the iOS version number even when targeting
711 getOSVersion(Major, Minor, Micro);
712 // Default to 5.0 (or 7.0 for arm64).
714 Major = (getArch() == aarch64) ? 7 : 5;
719 void Triple::setTriple(const Twine &Str) {
723 void Triple::setArch(ArchType Kind) {
724 setArchName(getArchTypeName(Kind));
727 void Triple::setVendor(VendorType Kind) {
728 setVendorName(getVendorTypeName(Kind));
731 void Triple::setOS(OSType Kind) {
732 setOSName(getOSTypeName(Kind));
735 void Triple::setEnvironment(EnvironmentType Kind) {
736 setEnvironmentName(getEnvironmentTypeName(Kind));
739 void Triple::setObjectFormat(ObjectFormatType Kind) {
740 if (Environment == UnknownEnvironment)
741 return setEnvironmentName(getObjectFormatTypeName(Kind));
743 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
744 getObjectFormatTypeName(Kind)).str());
747 void Triple::setArchName(StringRef Str) {
748 // Work around a miscompilation bug for Twines in gcc 4.0.3.
749 SmallString<64> Triple;
752 Triple += getVendorName();
754 Triple += getOSAndEnvironmentName();
755 setTriple(Triple.str());
758 void Triple::setVendorName(StringRef Str) {
759 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
762 void Triple::setOSName(StringRef Str) {
763 if (hasEnvironment())
764 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
765 "-" + getEnvironmentName());
767 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
770 void Triple::setEnvironmentName(StringRef Str) {
771 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
775 void Triple::setOSAndEnvironmentName(StringRef Str) {
776 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
779 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
781 case llvm::Triple::UnknownArch:
784 case llvm::Triple::msp430:
787 case llvm::Triple::amdil:
788 case llvm::Triple::arm:
789 case llvm::Triple::armeb:
790 case llvm::Triple::hexagon:
791 case llvm::Triple::le32:
792 case llvm::Triple::mips:
793 case llvm::Triple::mipsel:
794 case llvm::Triple::nvptx:
795 case llvm::Triple::ppc:
796 case llvm::Triple::r600:
797 case llvm::Triple::sparc:
798 case llvm::Triple::tce:
799 case llvm::Triple::thumb:
800 case llvm::Triple::thumbeb:
801 case llvm::Triple::x86:
802 case llvm::Triple::xcore:
803 case llvm::Triple::spir:
804 case llvm::Triple::kalimba:
807 case llvm::Triple::aarch64:
808 case llvm::Triple::aarch64_be:
809 case llvm::Triple::mips64:
810 case llvm::Triple::mips64el:
811 case llvm::Triple::nvptx64:
812 case llvm::Triple::ppc64:
813 case llvm::Triple::ppc64le:
814 case llvm::Triple::sparcv9:
815 case llvm::Triple::systemz:
816 case llvm::Triple::x86_64:
817 case llvm::Triple::spir64:
820 llvm_unreachable("Invalid architecture value");
823 bool Triple::isArch64Bit() const {
824 return getArchPointerBitWidth(getArch()) == 64;
827 bool Triple::isArch32Bit() const {
828 return getArchPointerBitWidth(getArch()) == 32;
831 bool Triple::isArch16Bit() const {
832 return getArchPointerBitWidth(getArch()) == 16;
835 Triple Triple::get32BitArchVariant() const {
838 case Triple::UnknownArch:
839 case Triple::aarch64:
840 case Triple::aarch64_be:
842 case Triple::systemz:
843 case Triple::ppc64le:
844 T.setArch(UnknownArch);
851 case Triple::hexagon:
852 case Triple::kalimba:
862 case Triple::thumbeb:
868 case Triple::mips64: T.setArch(Triple::mips); break;
869 case Triple::mips64el: T.setArch(Triple::mipsel); break;
870 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
871 case Triple::ppc64: T.setArch(Triple::ppc); break;
872 case Triple::sparcv9: T.setArch(Triple::sparc); break;
873 case Triple::x86_64: T.setArch(Triple::x86); break;
874 case Triple::spir64: T.setArch(Triple::spir); break;
879 Triple Triple::get64BitArchVariant() const {
882 case Triple::UnknownArch:
886 case Triple::hexagon:
887 case Triple::kalimba:
893 case Triple::thumbeb:
895 T.setArch(UnknownArch);
898 case Triple::aarch64:
899 case Triple::aarch64_be:
902 case Triple::mips64el:
903 case Triple::nvptx64:
905 case Triple::ppc64le:
906 case Triple::sparcv9:
907 case Triple::systemz:
912 case Triple::mips: T.setArch(Triple::mips64); break;
913 case Triple::mipsel: T.setArch(Triple::mips64el); break;
914 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
915 case Triple::ppc: T.setArch(Triple::ppc64); break;
916 case Triple::sparc: T.setArch(Triple::sparcv9); break;
917 case Triple::x86: T.setArch(Triple::x86_64); break;
918 case Triple::spir: T.setArch(Triple::spir64); break;
923 // FIXME: tblgen this.
924 const char *Triple::getARMCPUForArch(StringRef MArch) const {
926 MArch = getArchName();
929 case llvm::Triple::NetBSD:
930 if (MArch == "armv6")
931 return "arm1176jzf-s";
933 case llvm::Triple::Win32:
934 // FIXME: this is invalid for WindowsCE
940 const char *result = nullptr;
941 size_t offset = StringRef::npos;
942 if (MArch.startswith("arm"))
944 if (MArch.startswith("thumb"))
946 if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
948 if (offset != StringRef::npos)
949 result = llvm::StringSwitch<const char *>(MArch.substr(offset))
950 .Cases("v2", "v2a", "arm2")
952 .Case("v3m", "arm7m")
953 .Case("v4", "strongarm")
954 .Case("v4t", "arm7tdmi")
955 .Cases("v5", "v5t", "arm10tdmi")
956 .Cases("v5e", "v5te", "arm1022e")
957 .Case("v5tej", "arm926ej-s")
958 .Cases("v6", "v6k", "arm1136jf-s")
959 .Case("v6j", "arm1136j-s")
960 .Cases("v6z", "v6zk", "arm1176jzf-s")
961 .Case("v6t2", "arm1156t2-s")
962 .Cases("v6m", "v6-m", "cortex-m0")
963 .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
964 .Cases("v7s", "v7-s", "swift")
965 .Cases("v7r", "v7-r", "cortex-r4")
966 .Cases("v7m", "v7-m", "cortex-m3")
967 .Cases("v7em", "v7e-m", "cortex-m4")
968 .Cases("v8", "v8a", "v8-a", "cortex-a53")
971 result = llvm::StringSwitch<const char *>(MArch)
972 .Case("ep9312", "ep9312")
973 .Case("iwmmxt", "iwmmxt")
974 .Case("xscale", "xscale")
980 // If all else failed, return the most base CPU with thumb interworking
981 // supported by LLVM.
982 // FIXME: Should warn once that we're falling back.
984 case llvm::Triple::NetBSD:
985 switch (getEnvironment()) {
986 case llvm::Triple::GNUEABIHF:
987 case llvm::Triple::GNUEABI:
988 case llvm::Triple::EABIHF:
989 case llvm::Triple::EABI:
995 switch (getEnvironment()) {
996 case llvm::Triple::EABIHF:
997 case llvm::Triple::GNUEABIHF:
998 return "arm1176jzf-s";