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/SmallString.h"
12 #include "llvm/ADT/STLExtras.h"
16 const char *Triple::getArchTypeName(ArchType Kind) {
18 case InvalidArch: return "<invalid>";
19 case UnknownArch: return "unknown";
21 case alpha: return "alpha";
22 case arm: return "arm";
23 case bfin: return "bfin";
24 case cellspu: return "cellspu";
25 case mips: return "mips";
26 case mipsel: return "mipsel";
27 case msp430: return "msp430";
28 case ppc64: return "powerpc64";
29 case ppc: return "powerpc";
30 case sparc: return "sparc";
31 case sparcv9: return "sparcv9";
32 case systemz: return "s390x";
33 case tce: return "tce";
34 case thumb: return "thumb";
35 case x86: return "i386";
36 case x86_64: return "x86_64";
37 case xcore: return "xcore";
38 case mblaze: return "mblaze";
39 case ptx32: return "ptx32";
40 case ptx64: return "ptx64";
46 const char *Triple::getArchTypePrefix(ArchType Kind) {
51 case alpha: return "alpha";
54 case thumb: return "arm";
56 case bfin: return "bfin";
58 case cellspu: return "spu";
61 case ppc: return "ppc";
63 case mblaze: return "mblaze";
66 case sparc: return "sparc";
69 case x86_64: return "x86";
71 case xcore: return "xcore";
73 case ptx32: return "ptx";
74 case ptx64: return "ptx";
78 const char *Triple::getVendorTypeName(VendorType Kind) {
80 case UnknownVendor: return "unknown";
82 case Apple: return "apple";
84 case SCEI: return "scei";
90 const char *Triple::getOSTypeName(OSType Kind) {
92 case UnknownOS: return "unknown";
94 case AuroraUX: return "auroraux";
95 case Cygwin: return "cygwin";
96 case Darwin: return "darwin";
97 case DragonFly: return "dragonfly";
98 case FreeBSD: return "freebsd";
99 case IOS: return "ios";
100 case KFreeBSD: return "kfreebsd";
101 case Linux: return "linux";
102 case Lv2: return "lv2";
103 case MacOSX: return "macosx";
104 case MinGW32: return "mingw32";
105 case NetBSD: return "netbsd";
106 case OpenBSD: return "openbsd";
107 case Psp: return "psp";
108 case Solaris: return "solaris";
109 case Win32: return "win32";
110 case Haiku: return "haiku";
111 case Minix: return "minix";
112 case RTEMS: return "rtems";
118 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
120 case UnknownEnvironment: return "unknown";
121 case GNU: return "gnu";
122 case GNUEABI: return "gnueabi";
123 case EABI: return "eabi";
124 case MachO: return "macho";
130 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
137 if (Name == "cellspu")
141 if (Name == "mipsel")
143 if (Name == "msp430")
151 if (Name == "mblaze")
155 if (Name == "sparcv9")
157 if (Name == "systemz")
165 if (Name == "x86-64")
177 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
178 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
179 // archs which Darwin doesn't use.
181 // The matching this routine does is fairly pointless, since it is neither the
182 // complete architecture list, nor a reasonable subset. The problem is that
183 // historically the driver driver accepts this and also ties its -march=
184 // handling to the architecture name, so we need to be careful before removing
187 // This code must be kept in sync with Clang's Darwin specific argument
190 if (Str == "ppc" || Str == "ppc601" || Str == "ppc603" || Str == "ppc604" ||
191 Str == "ppc604e" || Str == "ppc750" || Str == "ppc7400" ||
192 Str == "ppc7450" || Str == "ppc970")
196 return Triple::ppc64;
198 if (Str == "i386" || Str == "i486" || Str == "i486SX" || Str == "pentium" ||
199 Str == "i586" || Str == "pentpro" || Str == "i686" || Str == "pentIIm3" ||
200 Str == "pentIIm5" || Str == "pentium4")
204 return Triple::x86_64;
206 // This is derived from the driver driver.
207 if (Str == "arm" || Str == "armv4t" || Str == "armv5" || Str == "xscale" ||
208 Str == "armv6" || Str == "armv7" || Str == "armv7f" || Str == "armv7k" ||
213 return Triple::ptx32;
215 return Triple::ptx64;
217 return Triple::UnknownArch;
220 // Returns architecture name that is understood by the target assembler.
221 const char *Triple::getArchNameForAssembler() {
222 if (!isOSDarwin() && getVendor() != Triple::Apple)
225 StringRef Str = getArchName();
230 if (Str == "powerpc")
232 if (Str == "powerpc64")
234 if (Str == "mblaze" || Str == "microblaze")
238 if (Str == "armv4t" || Str == "thumbv4t")
240 if (Str == "armv5" || Str == "armv5e" || Str == "thumbv5"
241 || Str == "thumbv5e")
243 if (Str == "armv6" || Str == "thumbv6")
245 if (Str == "armv7" || Str == "thumbv7")
256 Triple::ArchType Triple::ParseArch(StringRef ArchName) {
257 if (ArchName.size() == 4 && ArchName[0] == 'i' &&
258 ArchName[2] == '8' && ArchName[3] == '6' &&
259 ArchName[1] - '3' < 6) // i[3-9]86
261 else if (ArchName == "amd64" || ArchName == "x86_64")
263 else if (ArchName == "bfin")
265 else if (ArchName == "powerpc")
267 else if ((ArchName == "powerpc64") || (ArchName == "ppu"))
269 else if (ArchName == "mblaze")
271 else if (ArchName == "arm" ||
272 ArchName.startswith("armv") ||
273 ArchName == "xscale")
275 else if (ArchName == "thumb" ||
276 ArchName.startswith("thumbv"))
278 else if (ArchName.startswith("alpha"))
280 else if (ArchName == "spu" || ArchName == "cellspu")
282 else if (ArchName == "msp430")
284 else if (ArchName == "mips" || ArchName == "mipseb" ||
285 ArchName == "mipsallegrex")
287 else if (ArchName == "mipsel" || ArchName == "mipsallegrexel" ||
290 else if (ArchName == "sparc")
292 else if (ArchName == "sparcv9")
294 else if (ArchName == "s390x")
296 else if (ArchName == "tce")
298 else if (ArchName == "xcore")
300 else if (ArchName == "ptx32")
302 else if (ArchName == "ptx64")
308 Triple::VendorType Triple::ParseVendor(StringRef VendorName) {
309 if (VendorName == "apple")
311 else if (VendorName == "pc")
313 else if (VendorName == "scei")
316 return UnknownVendor;
319 Triple::OSType Triple::ParseOS(StringRef OSName) {
320 if (OSName.startswith("auroraux"))
322 else if (OSName.startswith("cygwin"))
324 else if (OSName.startswith("darwin"))
326 else if (OSName.startswith("dragonfly"))
328 else if (OSName.startswith("freebsd"))
330 else if (OSName.startswith("ios"))
332 else if (OSName.startswith("kfreebsd"))
334 else if (OSName.startswith("linux"))
336 else if (OSName.startswith("lv2"))
338 else if (OSName.startswith("macosx"))
340 else if (OSName.startswith("mingw32"))
342 else if (OSName.startswith("netbsd"))
344 else if (OSName.startswith("openbsd"))
346 else if (OSName.startswith("psp"))
348 else if (OSName.startswith("solaris"))
350 else if (OSName.startswith("win32"))
352 else if (OSName.startswith("haiku"))
354 else if (OSName.startswith("minix"))
356 else if (OSName.startswith("rtems"))
362 Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) {
363 if (EnvironmentName.startswith("eabi"))
365 else if (EnvironmentName.startswith("gnueabi"))
367 else if (EnvironmentName.startswith("gnu"))
369 else if (EnvironmentName.startswith("macho"))
372 return UnknownEnvironment;
375 void Triple::Parse() const {
376 assert(!isInitialized() && "Invalid parse call.");
378 Arch = ParseArch(getArchName());
379 Vendor = ParseVendor(getVendorName());
380 OS = ParseOS(getOSName());
381 Environment = ParseEnvironment(getEnvironmentName());
383 assert(isInitialized() && "Failed to initialize!");
386 std::string Triple::normalize(StringRef Str) {
387 // Parse into components.
388 SmallVector<StringRef, 4> Components;
389 for (size_t First = 0, Last = 0; Last != StringRef::npos; First = Last + 1) {
390 Last = Str.find('-', First);
391 Components.push_back(Str.slice(First, Last));
394 // If the first component corresponds to a known architecture, preferentially
395 // use it for the architecture. If the second component corresponds to a
396 // known vendor, preferentially use it for the vendor, etc. This avoids silly
397 // component movement when a component parses as (eg) both a valid arch and a
399 ArchType Arch = UnknownArch;
400 if (Components.size() > 0)
401 Arch = ParseArch(Components[0]);
402 VendorType Vendor = UnknownVendor;
403 if (Components.size() > 1)
404 Vendor = ParseVendor(Components[1]);
405 OSType OS = UnknownOS;
406 if (Components.size() > 2)
407 OS = ParseOS(Components[2]);
408 EnvironmentType Environment = UnknownEnvironment;
409 if (Components.size() > 3)
410 Environment = ParseEnvironment(Components[3]);
412 // Note which components are already in their final position. These will not
415 Found[0] = Arch != UnknownArch;
416 Found[1] = Vendor != UnknownVendor;
417 Found[2] = OS != UnknownOS;
418 Found[3] = Environment != UnknownEnvironment;
420 // If they are not there already, permute the components into their canonical
421 // positions by seeing if they parse as a valid architecture, and if so moving
422 // the component to the architecture position etc.
423 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
425 continue; // Already in the canonical position.
427 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
428 // Do not reparse any components that already matched.
429 if (Idx < array_lengthof(Found) && Found[Idx])
432 // Does this component parse as valid for the target position?
434 StringRef Comp = Components[Idx];
437 assert(false && "unexpected component type!");
439 Arch = ParseArch(Comp);
440 Valid = Arch != UnknownArch;
443 Vendor = ParseVendor(Comp);
444 Valid = Vendor != UnknownVendor;
448 Valid = OS != UnknownOS;
451 Environment = ParseEnvironment(Comp);
452 Valid = Environment != UnknownEnvironment;
456 continue; // Nope, try the next component.
458 // Move the component to the target position, pushing any non-fixed
459 // components that are in the way to the right. This tends to give
460 // good results in the common cases of a forgotten vendor component
461 // or a wrongly positioned environment.
463 // Insert left, pushing the existing components to the right. For
464 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
465 StringRef CurrentComponent(""); // The empty component.
466 // Replace the component we are moving with an empty component.
467 std::swap(CurrentComponent, Components[Idx]);
468 // Insert the component being moved at Pos, displacing any existing
469 // components to the right.
470 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
471 // Skip over any fixed components.
472 while (i < array_lengthof(Found) && Found[i]) ++i;
473 // Place the component at the new position, getting the component
474 // that was at this position - it will be moved right.
475 std::swap(CurrentComponent, Components[i]);
477 } else if (Pos > Idx) {
478 // Push right by inserting empty components until the component at Idx
479 // reaches the target position Pos. For example, pc-a -> -pc-a when
480 // moving pc to the second position.
482 // Insert one empty component at Idx.
483 StringRef CurrentComponent(""); // The empty component.
484 for (unsigned i = Idx; i < Components.size();) {
485 // Place the component at the new position, getting the component
486 // that was at this position - it will be moved right.
487 std::swap(CurrentComponent, Components[i]);
488 // If it was placed on top of an empty component then we are done.
489 if (CurrentComponent.empty())
491 // Advance to the next component, skipping any fixed components.
492 while (++i < array_lengthof(Found) && Found[i])
495 // The last component was pushed off the end - append it.
496 if (!CurrentComponent.empty())
497 Components.push_back(CurrentComponent);
499 // Advance Idx to the component's new position.
500 while (++Idx < array_lengthof(Found) && Found[Idx]) {}
501 } while (Idx < Pos); // Add more until the final position is reached.
503 assert(Pos < Components.size() && Components[Pos] == Comp &&
504 "Component moved wrong!");
510 // Special case logic goes here. At this point Arch, Vendor and OS have the
511 // correct values for the computed components.
513 // Stick the corrected components back together to form the normalized string.
514 std::string Normalized;
515 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
516 if (i) Normalized += '-';
517 Normalized += Components[i];
522 StringRef Triple::getArchName() const {
523 return StringRef(Data).split('-').first; // Isolate first component
526 StringRef Triple::getVendorName() const {
527 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
528 return Tmp.split('-').first; // Isolate second component
531 StringRef Triple::getOSName() const {
532 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
533 Tmp = Tmp.split('-').second; // Strip second component
534 return Tmp.split('-').first; // Isolate third component
537 StringRef Triple::getEnvironmentName() const {
538 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
539 Tmp = Tmp.split('-').second; // Strip second component
540 return Tmp.split('-').second; // Strip third component
543 StringRef Triple::getOSAndEnvironmentName() const {
544 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
545 return Tmp.split('-').second; // Strip second component
548 static unsigned EatNumber(StringRef &Str) {
549 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
553 // Consume the leading digit.
554 Result = Result*10 + (Str[0] - '0');
558 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
563 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
564 unsigned &Micro) const {
565 StringRef OSName = getOSName();
567 // Assume that the OS portion of the triple starts with the canonical name.
568 StringRef OSTypeName = getOSTypeName(getOS());
569 if (OSName.startswith(OSTypeName))
570 OSName = OSName.substr(OSTypeName.size());
572 // Any unset version defaults to 0.
573 Major = Minor = Micro = 0;
575 // Parse up to three components.
576 unsigned *Components[3] = { &Major, &Minor, &Micro };
577 for (unsigned i = 0; i != 3; ++i) {
578 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
581 // Consume the leading number.
582 *Components[i] = EatNumber(OSName);
584 // Consume the separator, if present.
585 if (OSName.startswith("."))
586 OSName = OSName.substr(1);
590 void Triple::setTriple(const Twine &Str) {
595 void Triple::setArch(ArchType Kind) {
596 setArchName(getArchTypeName(Kind));
599 void Triple::setVendor(VendorType Kind) {
600 setVendorName(getVendorTypeName(Kind));
603 void Triple::setOS(OSType Kind) {
604 setOSName(getOSTypeName(Kind));
607 void Triple::setEnvironment(EnvironmentType Kind) {
608 setEnvironmentName(getEnvironmentTypeName(Kind));
611 void Triple::setArchName(StringRef Str) {
612 // Work around a miscompilation bug for Twines in gcc 4.0.3.
613 SmallString<64> Triple;
616 Triple += getVendorName();
618 Triple += getOSAndEnvironmentName();
619 setTriple(Triple.str());
622 void Triple::setVendorName(StringRef Str) {
623 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
626 void Triple::setOSName(StringRef Str) {
627 if (hasEnvironment())
628 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
629 "-" + getEnvironmentName());
631 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
634 void Triple::setEnvironmentName(StringRef Str) {
635 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
639 void Triple::setOSAndEnvironmentName(StringRef Str) {
640 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);