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 ptx: return "ptx";
50 const char *Triple::getArchTypePrefix(ArchType Kind) {
55 case alpha: return "alpha";
58 case thumb: return "arm";
60 case bfin: return "bfin";
62 case cellspu: return "spu";
65 case ppc: return "ppc";
67 case mblaze: return "mblaze";
70 case sparc: return "sparc";
73 case x86_64: return "x86";
75 case xcore: return "xcore";
77 case ptx: return "ptx";
81 const char *Triple::getVendorTypeName(VendorType Kind) {
83 case UnknownVendor: return "unknown";
85 case Apple: return "apple";
87 case NoVendor: return "none";
93 const char *Triple::getOSTypeName(OSType Kind) {
95 case UnknownOS: return "unknown";
97 case AuroraUX: return "auroraux";
98 case Cygwin: return "cygwin";
99 case Darwin: return "darwin";
100 case DragonFly: return "dragonfly";
101 case FreeBSD: return "freebsd";
102 case Linux: return "linux";
103 case Lv2: return "lv2";
104 case MinGW32: return "mingw32";
105 case MinGW64: return "mingw64";
106 case NetBSD: return "netbsd";
107 case OpenBSD: return "openbsd";
108 case Psp: return "psp";
109 case Solaris: return "solaris";
110 case Win32: return "win32";
111 case Haiku: return "haiku";
112 case Minix: return "minix";
113 case NoOS: return "none";
119 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
121 case UnknownEnvironment: return "unknown";
122 case GNU: return "gnu";
123 case GNUEABI: return "gnueabi";
124 case EABI: return "eabi";
125 case MachO: return "macho";
131 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
138 if (Name == "cellspu")
142 if (Name == "mipsel")
144 if (Name == "msp430")
150 if (Name == "mblaze")
154 if (Name == "sparcv9")
156 if (Name == "systemz")
164 if (Name == "x86-64")
174 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
175 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
176 // archs which Darwin doesn't use.
178 // The matching this routine does is fairly pointless, since it is neither the
179 // complete architecture list, nor a reasonable subset. The problem is that
180 // historically the driver driver accepts this and also ties its -march=
181 // handling to the architecture name, so we need to be careful before removing
184 // This code must be kept in sync with Clang's Darwin specific argument
187 if (Str == "ppc" || Str == "ppc601" || Str == "ppc603" || Str == "ppc604" ||
188 Str == "ppc604e" || Str == "ppc750" || Str == "ppc7400" ||
189 Str == "ppc7450" || Str == "ppc970")
193 return Triple::ppc64;
195 if (Str == "i386" || Str == "i486" || Str == "i486SX" || Str == "pentium" ||
196 Str == "i586" || Str == "pentpro" || Str == "i686" || Str == "pentIIm3" ||
197 Str == "pentIIm5" || Str == "pentium4")
201 return Triple::x86_64;
203 // This is derived from the driver driver.
204 if (Str == "arm" || Str == "armv4t" || Str == "armv5" || Str == "xscale" ||
205 Str == "armv6" || Str == "armv7")
211 return Triple::UnknownArch;
214 // Returns architecture name that is understood by the target assembler.
215 const char *Triple::getArchNameForAssembler() {
216 if (getOS() != Triple::Darwin && getVendor() != Triple::Apple)
219 StringRef Str = getArchName();
224 if (Str == "powerpc")
226 if (Str == "powerpc64")
228 if (Str == "mblaze" || Str == "microblaze")
232 if (Str == "armv4t" || Str == "thumbv4t")
234 if (Str == "armv5" || Str == "armv5e" || Str == "thumbv5"
235 || Str == "thumbv5e")
237 if (Str == "armv6" || Str == "thumbv6")
239 if (Str == "armv7" || Str == "thumbv7")
248 Triple::ArchType Triple::ParseArch(StringRef ArchName) {
249 if (ArchName.size() == 4 && ArchName[0] == 'i' &&
250 ArchName[2] == '8' && ArchName[3] == '6' &&
251 ArchName[1] - '3' < 6) // i[3-9]86
253 else if (ArchName == "amd64" || ArchName == "x86_64")
255 else if (ArchName == "bfin")
257 else if (ArchName == "powerpc")
259 else if ((ArchName == "powerpc64") || (ArchName == "ppu"))
261 else if (ArchName == "mblaze")
263 else if (ArchName == "arm" ||
264 ArchName.startswith("armv") ||
265 ArchName == "xscale")
267 else if (ArchName == "thumb" ||
268 ArchName.startswith("thumbv"))
270 else if (ArchName.startswith("alpha"))
272 else if (ArchName == "spu" || ArchName == "cellspu")
274 else if (ArchName == "msp430")
276 else if (ArchName == "mips" || ArchName == "mipsallegrex")
278 else if (ArchName == "mipsel" || ArchName == "mipsallegrexel" ||
281 else if (ArchName == "sparc")
283 else if (ArchName == "sparcv9")
285 else if (ArchName == "s390x")
287 else if (ArchName == "tce")
289 else if (ArchName == "xcore")
291 else if (ArchName == "ptx")
297 Triple::VendorType Triple::ParseVendor(StringRef VendorName) {
298 if (VendorName == "apple")
300 else if (VendorName == "pc")
302 else if (VendorName == "none")
305 return UnknownVendor;
308 Triple::OSType Triple::ParseOS(StringRef OSName) {
309 if (OSName.startswith("auroraux"))
311 else if (OSName.startswith("cygwin"))
313 else if (OSName.startswith("darwin"))
315 else if (OSName.startswith("dragonfly"))
317 else if (OSName.startswith("freebsd"))
319 else if (OSName.startswith("linux"))
321 else if (OSName.startswith("lv2"))
323 else if (OSName.startswith("mingw32"))
325 else if (OSName.startswith("mingw64"))
327 else if (OSName.startswith("netbsd"))
329 else if (OSName.startswith("openbsd"))
331 else if (OSName.startswith("psp"))
333 else if (OSName.startswith("solaris"))
335 else if (OSName.startswith("win32"))
337 else if (OSName.startswith("haiku"))
339 else if (OSName.startswith("minix"))
341 else if (OSName.startswith("eabi"))
347 Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) {
348 if (EnvironmentName.startswith("eabi"))
350 else if (EnvironmentName.startswith("gnueabi"))
352 else if (EnvironmentName.startswith("gnu"))
354 else if (EnvironmentName.startswith("macho"))
357 return UnknownEnvironment;
360 void Triple::Parse() const {
361 assert(!isInitialized() && "Invalid parse call.");
363 Arch = ParseArch(getArchName());
364 Vendor = ParseVendor(getVendorName());
365 OS = ParseOS(getOSName());
367 // Some targets don't have an OS (embedded systems)
368 Environment = ParseEnvironment(getOSName());
370 Environment = ParseEnvironment(getEnvironmentName());
373 assert(isInitialized() && "Failed to initialize!");
376 std::string Triple::normalize(StringRef Str) {
377 // Parse into components.
378 SmallVector<StringRef, 4> Components;
379 for (size_t First = 0, Last = 0; Last != StringRef::npos; First = Last + 1) {
380 Last = Str.find('-', First);
381 Components.push_back(Str.slice(First, Last));
384 // If the first component corresponds to a known architecture, preferentially
385 // use it for the architecture. If the second component corresponds to a
386 // known vendor, preferentially use it for the vendor, etc. This avoids silly
387 // component movement when a component parses as (eg) both a valid arch and a
389 ArchType Arch = UnknownArch;
390 if (Components.size() > 0)
391 Arch = ParseArch(Components[0]);
392 VendorType Vendor = UnknownVendor;
393 if (Components.size() > 1)
394 Vendor = ParseVendor(Components[1]);
395 OSType OS = UnknownOS;
396 if (Components.size() > 2)
397 OS = ParseOS(Components[2]);
398 EnvironmentType Environment = UnknownEnvironment;
399 if (Components.size() > 3)
400 Environment = ParseEnvironment(Components[3]);
402 // Note which components are already in their final position. These will not
405 Found[0] = Arch != UnknownArch;
406 Found[1] = Vendor != UnknownVendor;
407 Found[2] = OS != UnknownOS;
408 Found[3] = Environment != UnknownEnvironment;
410 // If they are not there already, permute the components into their canonical
411 // positions by seeing if they parse as a valid architecture, and if so moving
412 // the component to the architecture position etc.
413 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
415 continue; // Already in the canonical position.
417 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
418 // Do not reparse any components that already matched.
419 if (Idx < array_lengthof(Found) && Found[Idx])
422 // Does this component parse as valid for the target position?
424 StringRef Comp = Components[Idx];
427 assert(false && "unexpected component type!");
429 Arch = ParseArch(Comp);
430 Valid = Arch != UnknownArch;
433 Vendor = ParseVendor(Comp);
434 Valid = Vendor != UnknownVendor;
438 // Some targets don't have an OS (embedded systems)
440 Environment = ParseEnvironment(Comp);
441 Valid = Environment != UnknownEnvironment;
443 Valid = OS != UnknownOS;
447 Environment = ParseEnvironment(Comp);
448 Valid = Environment != UnknownEnvironment;
452 continue; // Nope, try the next component.
454 // Move the component to the target position, pushing any non-fixed
455 // components that are in the way to the right. This tends to give
456 // good results in the common cases of a forgotten vendor component
457 // or a wrongly positioned environment.
459 // Insert left, pushing the existing components to the right. For
460 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
461 StringRef CurrentComponent(""); // The empty component.
462 // Replace the component we are moving with an empty component.
463 std::swap(CurrentComponent, Components[Idx]);
464 // Insert the component being moved at Pos, displacing any existing
465 // components to the right.
466 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
467 // Skip over any fixed components.
468 while (i < array_lengthof(Found) && Found[i]) ++i;
469 // Place the component at the new position, getting the component
470 // that was at this position - it will be moved right.
471 std::swap(CurrentComponent, Components[i]);
473 } else if (Pos > Idx) {
474 // Push right by inserting empty components until the component at Idx
475 // reaches the target position Pos. For example, pc-a -> -pc-a when
476 // moving pc to the second position.
478 // Insert one empty component at Idx.
479 StringRef CurrentComponent(""); // The empty component.
480 for (unsigned i = Idx; i < Components.size(); ++i) {
481 // Skip over any fixed components.
482 while (i < array_lengthof(Found) && Found[i]) ++i;
483 // Fix problem when Components vector is not big enough
484 if (i >= Components.size())
485 Components.push_back(StringRef(""));
486 // Place the component at the new position, getting the component
487 // that was at this position - it will be moved right.
488 std::swap(CurrentComponent, Components[i]);
489 // If it was placed on top of an empty component then we are done.
490 if (CurrentComponent.empty())
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");
548 unsigned Result = Str[0]-'0';
553 // Handle "darwin11".
554 if (Result == 1 && !Str.empty() && Str[0] >= '0' && Str[0] <= '9') {
555 Result = Result*10 + (Str[0] - '0');
563 /// getDarwinNumber - Parse the 'darwin number' out of the specific target
564 /// triple. For example, if we have darwin8.5 return 8,5,0. If any entry is
565 /// not defined, return 0's. This requires that the triple have an OSType of
566 /// darwin before it is called.
567 void Triple::getDarwinNumber(unsigned &Maj, unsigned &Min,
568 unsigned &Revision) const {
569 assert(getOS() == Darwin && "Not a darwin target triple!");
570 StringRef OSName = getOSName();
571 assert(OSName.startswith("darwin") && "Unknown darwin target triple!");
573 // Strip off "darwin".
574 OSName = OSName.substr(6);
576 Maj = Min = Revision = 0;
578 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
581 // The major version is the first digit.
582 Maj = EatNumber(OSName);
583 if (OSName.empty()) return;
585 // Handle minor version: 10.4.9 -> darwin8.9.
586 if (OSName[0] != '.')
590 OSName = OSName.substr(1);
592 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
595 Min = EatNumber(OSName);
596 if (OSName.empty()) return;
598 // Handle revision darwin8.9.1
599 if (OSName[0] != '.')
603 OSName = OSName.substr(1);
605 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
608 Revision = EatNumber(OSName);
611 void Triple::setTriple(const Twine &Str) {
616 void Triple::setArch(ArchType Kind) {
617 setArchName(getArchTypeName(Kind));
620 void Triple::setVendor(VendorType Kind) {
621 setVendorName(getVendorTypeName(Kind));
624 void Triple::setOS(OSType Kind) {
625 setOSName(getOSTypeName(Kind));
628 void Triple::setEnvironment(EnvironmentType Kind) {
629 setEnvironmentName(getEnvironmentTypeName(Kind));
632 void Triple::setArchName(StringRef Str) {
633 // Work around a miscompilation bug for Twines in gcc 4.0.3.
634 SmallString<64> Triple;
637 Triple += getVendorName();
639 Triple += getOSAndEnvironmentName();
640 setTriple(Triple.str());
643 void Triple::setVendorName(StringRef Str) {
644 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
647 void Triple::setOSName(StringRef Str) {
648 if (hasEnvironment())
649 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
650 "-" + getEnvironmentName());
652 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
655 void Triple::setEnvironmentName(StringRef Str) {
656 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
660 void Triple::setOSAndEnvironmentName(StringRef Str) {
661 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);