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";
130 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
137 if (Name == "cellspu")
141 if (Name == "mipsel")
143 if (Name == "msp430")
149 if (Name == "mblaze")
153 if (Name == "sparcv9")
155 if (Name == "systemz")
163 if (Name == "x86-64")
173 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
174 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
175 // archs which Darwin doesn't use.
177 // The matching this routine does is fairly pointless, since it is neither the
178 // complete architecture list, nor a reasonable subset. The problem is that
179 // historically the driver driver accepts this and also ties its -march=
180 // handling to the architecture name, so we need to be careful before removing
183 // This code must be kept in sync with Clang's Darwin specific argument
186 if (Str == "ppc" || Str == "ppc601" || Str == "ppc603" || Str == "ppc604" ||
187 Str == "ppc604e" || Str == "ppc750" || Str == "ppc7400" ||
188 Str == "ppc7450" || Str == "ppc970")
192 return Triple::ppc64;
194 if (Str == "i386" || Str == "i486" || Str == "i486SX" || Str == "pentium" ||
195 Str == "i586" || Str == "pentpro" || Str == "i686" || Str == "pentIIm3" ||
196 Str == "pentIIm5" || Str == "pentium4")
200 return Triple::x86_64;
202 // This is derived from the driver driver.
203 if (Str == "arm" || Str == "armv4t" || Str == "armv5" || Str == "xscale" ||
204 Str == "armv6" || Str == "armv7")
210 return Triple::UnknownArch;
213 // Returns architecture name that is understood by the target assembler.
214 const char *Triple::getArchNameForAssembler() {
215 if (getOS() != Triple::Darwin && getVendor() != Triple::Apple)
218 StringRef Str = getArchName();
223 if (Str == "powerpc")
225 if (Str == "powerpc64")
227 if (Str == "mblaze" || Str == "microblaze")
231 if (Str == "armv4t" || Str == "thumbv4t")
233 if (Str == "armv5" || Str == "armv5e" || Str == "thumbv5"
234 || Str == "thumbv5e")
236 if (Str == "armv6" || Str == "thumbv6")
238 if (Str == "armv7" || Str == "thumbv7")
247 Triple::ArchType Triple::ParseArch(StringRef ArchName) {
248 if (ArchName.size() == 4 && ArchName[0] == 'i' &&
249 ArchName[2] == '8' && ArchName[3] == '6' &&
250 ArchName[1] - '3' < 6) // i[3-9]86
252 else if (ArchName == "amd64" || ArchName == "x86_64")
254 else if (ArchName == "bfin")
256 else if (ArchName == "powerpc")
258 else if ((ArchName == "powerpc64") || (ArchName == "ppu"))
260 else if (ArchName == "mblaze")
262 else if (ArchName == "arm" ||
263 ArchName.startswith("armv") ||
264 ArchName == "xscale")
266 else if (ArchName == "thumb" ||
267 ArchName.startswith("thumbv"))
269 else if (ArchName.startswith("alpha"))
271 else if (ArchName == "spu" || ArchName == "cellspu")
273 else if (ArchName == "msp430")
275 else if (ArchName == "mips" || ArchName == "mipsallegrex")
277 else if (ArchName == "mipsel" || ArchName == "mipsallegrexel" ||
280 else if (ArchName == "sparc")
282 else if (ArchName == "sparcv9")
284 else if (ArchName == "s390x")
286 else if (ArchName == "tce")
288 else if (ArchName == "xcore")
290 else if (ArchName == "ptx")
296 Triple::VendorType Triple::ParseVendor(StringRef VendorName) {
297 if (VendorName == "apple")
299 else if (VendorName == "pc")
301 else if (VendorName == "none")
304 return UnknownVendor;
307 Triple::OSType Triple::ParseOS(StringRef OSName) {
308 if (OSName.startswith("auroraux"))
310 else if (OSName.startswith("cygwin"))
312 else if (OSName.startswith("darwin"))
314 else if (OSName.startswith("dragonfly"))
316 else if (OSName.startswith("freebsd"))
318 else if (OSName.startswith("linux"))
320 else if (OSName.startswith("lv2"))
322 else if (OSName.startswith("mingw32"))
324 else if (OSName.startswith("mingw64"))
326 else if (OSName.startswith("netbsd"))
328 else if (OSName.startswith("openbsd"))
330 else if (OSName.startswith("psp"))
332 else if (OSName.startswith("solaris"))
334 else if (OSName.startswith("win32"))
336 else if (OSName.startswith("haiku"))
338 else if (OSName.startswith("minix"))
340 else if (OSName.startswith("eabi"))
346 Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) {
347 if (EnvironmentName.startswith("eabi"))
349 else if (EnvironmentName.startswith("gnueabi"))
351 else if (EnvironmentName.startswith("gnu"))
354 return UnknownEnvironment;
357 void Triple::Parse() const {
358 assert(!isInitialized() && "Invalid parse call.");
360 Arch = ParseArch(getArchName());
361 Vendor = ParseVendor(getVendorName());
362 OS = ParseOS(getOSName());
364 // Some targets don't have an OS (embedded systems)
365 Environment = ParseEnvironment(getOSName());
367 Environment = ParseEnvironment(getEnvironmentName());
370 assert(isInitialized() && "Failed to initialize!");
373 std::string Triple::normalize(StringRef Str) {
374 // Parse into components.
375 SmallVector<StringRef, 4> Components;
376 for (size_t First = 0, Last = 0; Last != StringRef::npos; First = Last + 1) {
377 Last = Str.find('-', First);
378 Components.push_back(Str.slice(First, Last));
381 // If the first component corresponds to a known architecture, preferentially
382 // use it for the architecture. If the second component corresponds to a
383 // known vendor, preferentially use it for the vendor, etc. This avoids silly
384 // component movement when a component parses as (eg) both a valid arch and a
386 ArchType Arch = UnknownArch;
387 if (Components.size() > 0)
388 Arch = ParseArch(Components[0]);
389 VendorType Vendor = UnknownVendor;
390 if (Components.size() > 1)
391 Vendor = ParseVendor(Components[1]);
392 OSType OS = UnknownOS;
393 if (Components.size() > 2)
394 OS = ParseOS(Components[2]);
395 EnvironmentType Environment = UnknownEnvironment;
396 if (Components.size() > 3)
397 Environment = ParseEnvironment(Components[3]);
399 // Note which components are already in their final position. These will not
402 Found[0] = Arch != UnknownArch;
403 Found[1] = Vendor != UnknownVendor;
404 Found[2] = OS != UnknownOS;
405 Found[3] = Environment != UnknownEnvironment;
407 // If they are not there already, permute the components into their canonical
408 // positions by seeing if they parse as a valid architecture, and if so moving
409 // the component to the architecture position etc.
410 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
412 continue; // Already in the canonical position.
414 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
415 // Do not reparse any components that already matched.
416 if (Idx < array_lengthof(Found) && Found[Idx])
419 // Does this component parse as valid for the target position?
421 StringRef Comp = Components[Idx];
424 assert(false && "unexpected component type!");
426 Arch = ParseArch(Comp);
427 Valid = Arch != UnknownArch;
430 Vendor = ParseVendor(Comp);
431 Valid = Vendor != UnknownVendor;
435 // Some targets don't have an OS (embedded systems)
437 Environment = ParseEnvironment(Comp);
438 Valid = Environment != UnknownEnvironment;
440 Valid = OS != UnknownOS;
444 Environment = ParseEnvironment(Comp);
445 Valid = Environment != UnknownEnvironment;
449 continue; // Nope, try the next component.
451 // Move the component to the target position, pushing any non-fixed
452 // components that are in the way to the right. This tends to give
453 // good results in the common cases of a forgotten vendor component
454 // or a wrongly positioned environment.
456 // Insert left, pushing the existing components to the right. For
457 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
458 StringRef CurrentComponent(""); // The empty component.
459 // Replace the component we are moving with an empty component.
460 std::swap(CurrentComponent, Components[Idx]);
461 // Insert the component being moved at Pos, displacing any existing
462 // components to the right.
463 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
464 // Skip over any fixed components.
465 while (i < array_lengthof(Found) && Found[i]) ++i;
466 // Place the component at the new position, getting the component
467 // that was at this position - it will be moved right.
468 std::swap(CurrentComponent, Components[i]);
470 } else if (Pos > Idx) {
471 // Push right by inserting empty components until the component at Idx
472 // reaches the target position Pos. For example, pc-a -> -pc-a when
473 // moving pc to the second position.
475 // Insert one empty component at Idx.
476 StringRef CurrentComponent(""); // The empty component.
477 for (unsigned i = Idx; i < Components.size(); ++i) {
478 // Skip over any fixed components.
479 while (i < array_lengthof(Found) && Found[i]) ++i;
480 // Fix problem when Components vector is not big enough
481 if (i >= Components.size())
482 Components.push_back(StringRef(""));
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())
490 // The last component was pushed off the end - append it.
491 if (!CurrentComponent.empty())
492 Components.push_back(CurrentComponent);
494 // Advance Idx to the component's new position.
495 while (++Idx < array_lengthof(Found) && Found[Idx]) {}
496 } while (Idx < Pos); // Add more until the final position is reached.
498 assert(Pos < Components.size() && Components[Pos] == Comp &&
499 "Component moved wrong!");
505 // Special case logic goes here. At this point Arch, Vendor and OS have the
506 // correct values for the computed components.
508 // Stick the corrected components back together to form the normalized string.
509 std::string Normalized;
510 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
511 if (i) Normalized += '-';
512 Normalized += Components[i];
517 StringRef Triple::getArchName() const {
518 return StringRef(Data).split('-').first; // Isolate first component
521 StringRef Triple::getVendorName() const {
522 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
523 return Tmp.split('-').first; // Isolate second component
526 StringRef Triple::getOSName() const {
527 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
528 Tmp = Tmp.split('-').second; // Strip second component
529 return Tmp.split('-').first; // Isolate third component
532 StringRef Triple::getEnvironmentName() const {
533 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
534 Tmp = Tmp.split('-').second; // Strip second component
535 return Tmp.split('-').second; // Strip third component
538 StringRef Triple::getOSAndEnvironmentName() const {
539 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
540 return Tmp.split('-').second; // Strip second component
543 static unsigned EatNumber(StringRef &Str) {
544 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
545 unsigned Result = Str[0]-'0';
550 // Handle "darwin11".
551 if (Result == 1 && !Str.empty() && Str[0] >= '0' && Str[0] <= '9') {
552 Result = Result*10 + (Str[0] - '0');
560 /// getDarwinNumber - Parse the 'darwin number' out of the specific target
561 /// triple. For example, if we have darwin8.5 return 8,5,0. If any entry is
562 /// not defined, return 0's. This requires that the triple have an OSType of
563 /// darwin before it is called.
564 void Triple::getDarwinNumber(unsigned &Maj, unsigned &Min,
565 unsigned &Revision) const {
566 assert(getOS() == Darwin && "Not a darwin target triple!");
567 StringRef OSName = getOSName();
568 assert(OSName.startswith("darwin") && "Unknown darwin target triple!");
570 // Strip off "darwin".
571 OSName = OSName.substr(6);
573 Maj = Min = Revision = 0;
575 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
578 // The major version is the first digit.
579 Maj = EatNumber(OSName);
580 if (OSName.empty()) return;
582 // Handle minor version: 10.4.9 -> darwin8.9.
583 if (OSName[0] != '.')
587 OSName = OSName.substr(1);
589 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
592 Min = EatNumber(OSName);
593 if (OSName.empty()) return;
595 // Handle revision darwin8.9.1
596 if (OSName[0] != '.')
600 OSName = OSName.substr(1);
602 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
605 Revision = EatNumber(OSName);
608 void Triple::setTriple(const Twine &Str) {
613 void Triple::setArch(ArchType Kind) {
614 setArchName(getArchTypeName(Kind));
617 void Triple::setVendor(VendorType Kind) {
618 setVendorName(getVendorTypeName(Kind));
621 void Triple::setOS(OSType Kind) {
622 setOSName(getOSTypeName(Kind));
625 void Triple::setEnvironment(EnvironmentType Kind) {
626 setEnvironmentName(getEnvironmentTypeName(Kind));
629 void Triple::setArchName(StringRef Str) {
630 // Work around a miscompilation bug for Twines in gcc 4.0.3.
631 SmallString<64> Triple;
634 Triple += getVendorName();
636 Triple += getOSAndEnvironmentName();
637 setTriple(Triple.str());
640 void Triple::setVendorName(StringRef Str) {
641 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
644 void Triple::setOSName(StringRef Str) {
645 if (hasEnvironment())
646 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
647 "-" + getEnvironmentName());
649 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
652 void Triple::setEnvironmentName(StringRef Str) {
653 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
657 void Triple::setOSAndEnvironmentName(StringRef Str) {
658 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);