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"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/ADT/Twine.h"
21 const char *Triple::getArchTypeName(ArchType Kind) {
23 case InvalidArch: return "<invalid>";
24 case UnknownArch: return "unknown";
26 case alpha: return "alpha";
27 case arm: return "arm";
28 case bfin: return "bfin";
29 case cellspu: return "cellspu";
30 case mips: return "mips";
31 case mipsel: return "mipsel";
32 case msp430: return "msp430";
33 case ppc64: return "powerpc64";
34 case ppc: return "powerpc";
35 case sparc: return "sparc";
36 case sparcv9: return "sparcv9";
37 case systemz: return "s390x";
38 case tce: return "tce";
39 case thumb: return "thumb";
40 case x86: return "i386";
41 case x86_64: return "x86_64";
42 case xcore: return "xcore";
43 case mblaze: return "mblaze";
44 case ptx32: return "ptx32";
45 case ptx64: return "ptx64";
51 const char *Triple::getArchTypePrefix(ArchType Kind) {
56 case alpha: return "alpha";
59 case thumb: return "arm";
61 case bfin: return "bfin";
63 case cellspu: return "spu";
66 case ppc: return "ppc";
68 case mblaze: return "mblaze";
71 case sparc: return "sparc";
74 case x86_64: return "x86";
76 case xcore: return "xcore";
78 case ptx32: return "ptx";
79 case ptx64: return "ptx";
83 const char *Triple::getVendorTypeName(VendorType Kind) {
85 case UnknownVendor: return "unknown";
87 case Apple: return "apple";
89 case SCEI: return "scei";
95 const char *Triple::getOSTypeName(OSType Kind) {
97 case UnknownOS: return "unknown";
99 case AuroraUX: return "auroraux";
100 case Cygwin: return "cygwin";
101 case Darwin: return "darwin";
102 case DragonFly: return "dragonfly";
103 case FreeBSD: return "freebsd";
104 case IOS: return "ios";
105 case Linux: return "linux";
106 case Lv2: return "lv2";
107 case MacOSX: return "macosx";
108 case MinGW32: return "mingw32";
109 case NetBSD: return "netbsd";
110 case OpenBSD: return "openbsd";
111 case Psp: return "psp";
112 case Solaris: return "solaris";
113 case Win32: return "win32";
114 case Haiku: return "haiku";
115 case Minix: return "minix";
116 case RTEMS: return "rtems";
122 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
124 case UnknownEnvironment: return "unknown";
125 case GNU: return "gnu";
126 case GNUEABI: return "gnueabi";
127 case EABI: return "eabi";
128 case MachO: return "macho";
134 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
141 if (Name == "cellspu")
145 if (Name == "mipsel")
147 if (Name == "msp430")
153 if (Name == "mblaze")
157 if (Name == "sparcv9")
159 if (Name == "systemz")
167 if (Name == "x86-64")
179 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
180 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
181 // archs which Darwin doesn't use.
183 // The matching this routine does is fairly pointless, since it is neither the
184 // complete architecture list, nor a reasonable subset. The problem is that
185 // historically the driver driver accepts this and also ties its -march=
186 // handling to the architecture name, so we need to be careful before removing
189 // This code must be kept in sync with Clang's Darwin specific argument
192 if (Str == "ppc" || Str == "ppc601" || Str == "ppc603" || Str == "ppc604" ||
193 Str == "ppc604e" || Str == "ppc750" || Str == "ppc7400" ||
194 Str == "ppc7450" || Str == "ppc970")
198 return Triple::ppc64;
200 if (Str == "i386" || Str == "i486" || Str == "i486SX" || Str == "pentium" ||
201 Str == "i586" || Str == "pentpro" || Str == "i686" || Str == "pentIIm3" ||
202 Str == "pentIIm5" || Str == "pentium4")
206 return Triple::x86_64;
208 // This is derived from the driver driver.
209 if (Str == "arm" || Str == "armv4t" || Str == "armv5" || Str == "xscale" ||
210 Str == "armv6" || Str == "armv7")
214 return Triple::ptx32;
216 return Triple::ptx64;
218 return Triple::UnknownArch;
221 // Returns architecture name that is understood by the target assembler.
222 const char *Triple::getArchNameForAssembler() {
223 if (!isOSDarwin() && getVendor() != Triple::Apple)
226 StringRef Str = getArchName();
231 if (Str == "powerpc")
233 if (Str == "powerpc64")
235 if (Str == "mblaze" || Str == "microblaze")
239 if (Str == "armv4t" || Str == "thumbv4t")
241 if (Str == "armv5" || Str == "armv5e" || Str == "thumbv5"
242 || Str == "thumbv5e")
244 if (Str == "armv6" || Str == "thumbv6")
246 if (Str == "armv7" || Str == "thumbv7")
257 Triple::ArchType Triple::ParseArch(StringRef ArchName) {
258 if (ArchName.size() == 4 && ArchName[0] == 'i' &&
259 ArchName[2] == '8' && ArchName[3] == '6' &&
260 ArchName[1] - '3' < 6) // i[3-9]86
262 else if (ArchName == "amd64" || ArchName == "x86_64")
264 else if (ArchName == "bfin")
266 else if (ArchName == "powerpc")
268 else if ((ArchName == "powerpc64") || (ArchName == "ppu"))
270 else if (ArchName == "mblaze")
272 else if (ArchName == "arm" ||
273 ArchName.startswith("armv") ||
274 ArchName == "xscale")
276 else if (ArchName == "thumb" ||
277 ArchName.startswith("thumbv"))
279 else if (ArchName.startswith("alpha"))
281 else if (ArchName == "spu" || ArchName == "cellspu")
283 else if (ArchName == "msp430")
285 else if (ArchName == "mips" || 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("linux"))
334 else if (OSName.startswith("lv2"))
336 else if (OSName.startswith("macosx"))
338 else if (OSName.startswith("mingw32"))
340 else if (OSName.startswith("netbsd"))
342 else if (OSName.startswith("openbsd"))
344 else if (OSName.startswith("psp"))
346 else if (OSName.startswith("solaris"))
348 else if (OSName.startswith("win32"))
350 else if (OSName.startswith("haiku"))
352 else if (OSName.startswith("minix"))
354 else if (OSName.startswith("rtems"))
360 Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) {
361 if (EnvironmentName.startswith("eabi"))
363 else if (EnvironmentName.startswith("gnueabi"))
365 else if (EnvironmentName.startswith("gnu"))
367 else if (EnvironmentName.startswith("macho"))
370 return UnknownEnvironment;
373 void Triple::Parse() const {
374 assert(!isInitialized() && "Invalid parse call.");
376 Arch = ParseArch(getArchName());
377 Vendor = ParseVendor(getVendorName());
378 OS = ParseOS(getOSName());
379 Environment = ParseEnvironment(getEnvironmentName());
381 assert(isInitialized() && "Failed to initialize!");
384 std::string Triple::normalize(StringRef Str) {
385 // Parse into components.
386 SmallVector<StringRef, 4> Components;
387 for (size_t First = 0, Last = 0; Last != StringRef::npos; First = Last + 1) {
388 Last = Str.find('-', First);
389 Components.push_back(Str.slice(First, Last));
392 // If the first component corresponds to a known architecture, preferentially
393 // use it for the architecture. If the second component corresponds to a
394 // known vendor, preferentially use it for the vendor, etc. This avoids silly
395 // component movement when a component parses as (eg) both a valid arch and a
397 ArchType Arch = UnknownArch;
398 if (Components.size() > 0)
399 Arch = ParseArch(Components[0]);
400 VendorType Vendor = UnknownVendor;
401 if (Components.size() > 1)
402 Vendor = ParseVendor(Components[1]);
403 OSType OS = UnknownOS;
404 if (Components.size() > 2)
405 OS = ParseOS(Components[2]);
406 EnvironmentType Environment = UnknownEnvironment;
407 if (Components.size() > 3)
408 Environment = ParseEnvironment(Components[3]);
410 // Note which components are already in their final position. These will not
413 Found[0] = Arch != UnknownArch;
414 Found[1] = Vendor != UnknownVendor;
415 Found[2] = OS != UnknownOS;
416 Found[3] = Environment != UnknownEnvironment;
418 // If they are not there already, permute the components into their canonical
419 // positions by seeing if they parse as a valid architecture, and if so moving
420 // the component to the architecture position etc.
421 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
423 continue; // Already in the canonical position.
425 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
426 // Do not reparse any components that already matched.
427 if (Idx < array_lengthof(Found) && Found[Idx])
430 // Does this component parse as valid for the target position?
432 StringRef Comp = Components[Idx];
435 assert(false && "unexpected component type!");
437 Arch = ParseArch(Comp);
438 Valid = Arch != UnknownArch;
441 Vendor = ParseVendor(Comp);
442 Valid = Vendor != UnknownVendor;
446 Valid = OS != UnknownOS;
449 Environment = ParseEnvironment(Comp);
450 Valid = Environment != UnknownEnvironment;
454 continue; // Nope, try the next component.
456 // Move the component to the target position, pushing any non-fixed
457 // components that are in the way to the right. This tends to give
458 // good results in the common cases of a forgotten vendor component
459 // or a wrongly positioned environment.
461 // Insert left, pushing the existing components to the right. For
462 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
463 StringRef CurrentComponent(""); // The empty component.
464 // Replace the component we are moving with an empty component.
465 std::swap(CurrentComponent, Components[Idx]);
466 // Insert the component being moved at Pos, displacing any existing
467 // components to the right.
468 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
469 // Skip over any fixed components.
470 while (i < array_lengthof(Found) && Found[i]) ++i;
471 // Place the component at the new position, getting the component
472 // that was at this position - it will be moved right.
473 std::swap(CurrentComponent, Components[i]);
475 } else if (Pos > Idx) {
476 // Push right by inserting empty components until the component at Idx
477 // reaches the target position Pos. For example, pc-a -> -pc-a when
478 // moving pc to the second position.
480 // Insert one empty component at Idx.
481 StringRef CurrentComponent(""); // The empty component.
482 for (unsigned i = Idx; i < Components.size();) {
483 // Place the component at the new position, getting the component
484 // that was at this position - it will be moved right.
485 std::swap(CurrentComponent, Components[i]);
486 // If it was placed on top of an empty component then we are done.
487 if (CurrentComponent.empty())
489 // Advance to the next component, skipping any fixed components.
490 while (++i < array_lengthof(Found) && Found[i])
493 // The last component was pushed off the end - append it.
494 if (!CurrentComponent.empty())
495 Components.push_back(CurrentComponent);
497 // Advance Idx to the component's new position.
498 while (++Idx < array_lengthof(Found) && Found[Idx]) {}
499 } while (Idx < Pos); // Add more until the final position is reached.
501 assert(Pos < Components.size() && Components[Pos] == Comp &&
502 "Component moved wrong!");
508 // Special case logic goes here. At this point Arch, Vendor and OS have the
509 // correct values for the computed components.
511 // Stick the corrected components back together to form the normalized string.
512 std::string Normalized;
513 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
514 if (i) Normalized += '-';
515 Normalized += Components[i];
520 StringRef Triple::getArchName() const {
521 return StringRef(Data).split('-').first; // Isolate first component
524 StringRef Triple::getVendorName() const {
525 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
526 return Tmp.split('-').first; // Isolate second component
529 StringRef Triple::getOSName() const {
530 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
531 Tmp = Tmp.split('-').second; // Strip second component
532 return Tmp.split('-').first; // Isolate third component
535 StringRef Triple::getEnvironmentName() const {
536 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
537 Tmp = Tmp.split('-').second; // Strip second component
538 return Tmp.split('-').second; // Strip third component
541 StringRef Triple::getOSAndEnvironmentName() const {
542 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
543 return Tmp.split('-').second; // Strip second component
546 static unsigned EatNumber(StringRef &Str) {
547 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
551 // Consume the leading digit.
552 Result = Result*10 + (Str[0] - '0');
556 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
561 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
562 unsigned &Micro) const {
563 StringRef OSName = getOSName();
565 // Assume that the OS portion of the triple starts with the canonical name.
566 StringRef OSTypeName = getOSTypeName(getOS());
567 if (OSName.startswith(OSTypeName))
568 OSName = OSName.substr(OSTypeName.size());
570 // Any unset version defaults to 0.
571 Major = Minor = Micro = 0;
573 // Parse up to three components.
574 unsigned *Components[3] = { &Major, &Minor, &Micro };
575 for (unsigned i = 0; i != 3; ++i) {
576 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
579 // Consume the leading number.
580 *Components[i] = EatNumber(OSName);
582 // Consume the separator, if present.
583 if (OSName.startswith("."))
584 OSName = OSName.substr(1);
588 void Triple::setTriple(const Twine &Str) {
593 void Triple::setArch(ArchType Kind) {
594 setArchName(getArchTypeName(Kind));
597 void Triple::setVendor(VendorType Kind) {
598 setVendorName(getVendorTypeName(Kind));
601 void Triple::setOS(OSType Kind) {
602 setOSName(getOSTypeName(Kind));
605 void Triple::setEnvironment(EnvironmentType Kind) {
606 setEnvironmentName(getEnvironmentTypeName(Kind));
609 void Triple::setArchName(StringRef Str) {
610 // Work around a miscompilation bug for Twines in gcc 4.0.3.
611 SmallString<64> Triple;
614 Triple += getVendorName();
616 Triple += getOSAndEnvironmentName();
617 setTriple(Triple.str());
620 void Triple::setVendorName(StringRef Str) {
621 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
624 void Triple::setOSName(StringRef Str) {
625 if (hasEnvironment())
626 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
627 "-" + getEnvironmentName());
629 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
632 void Triple::setEnvironmentName(StringRef Str) {
633 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
637 void Triple::setOSAndEnvironmentName(StringRef Str) {
638 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);