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";
121 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
123 case UnknownEnvironment: return "unknown";
124 case GNU: return "gnu";
125 case GNUEABI: return "gnueabi";
126 case EABI: return "eabi";
127 case MachO: return "macho";
133 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
140 if (Name == "cellspu")
144 if (Name == "mipsel")
146 if (Name == "msp430")
152 if (Name == "mblaze")
156 if (Name == "sparcv9")
158 if (Name == "systemz")
166 if (Name == "x86-64")
178 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
179 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
180 // archs which Darwin doesn't use.
182 // The matching this routine does is fairly pointless, since it is neither the
183 // complete architecture list, nor a reasonable subset. The problem is that
184 // historically the driver driver accepts this and also ties its -march=
185 // handling to the architecture name, so we need to be careful before removing
188 // This code must be kept in sync with Clang's Darwin specific argument
191 if (Str == "ppc" || Str == "ppc601" || Str == "ppc603" || Str == "ppc604" ||
192 Str == "ppc604e" || Str == "ppc750" || Str == "ppc7400" ||
193 Str == "ppc7450" || Str == "ppc970")
197 return Triple::ppc64;
199 if (Str == "i386" || Str == "i486" || Str == "i486SX" || Str == "pentium" ||
200 Str == "i586" || Str == "pentpro" || Str == "i686" || Str == "pentIIm3" ||
201 Str == "pentIIm5" || Str == "pentium4")
205 return Triple::x86_64;
207 // This is derived from the driver driver.
208 if (Str == "arm" || Str == "armv4t" || Str == "armv5" || Str == "xscale" ||
209 Str == "armv6" || Str == "armv7")
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 == "mipsallegrex")
286 else if (ArchName == "mipsel" || ArchName == "mipsallegrexel" ||
289 else if (ArchName == "sparc")
291 else if (ArchName == "sparcv9")
293 else if (ArchName == "s390x")
295 else if (ArchName == "tce")
297 else if (ArchName == "xcore")
299 else if (ArchName == "ptx32")
301 else if (ArchName == "ptx64")
307 Triple::VendorType Triple::ParseVendor(StringRef VendorName) {
308 if (VendorName == "apple")
310 else if (VendorName == "pc")
312 else if (VendorName == "scei")
315 return UnknownVendor;
318 Triple::OSType Triple::ParseOS(StringRef OSName) {
319 if (OSName.startswith("auroraux"))
321 else if (OSName.startswith("cygwin"))
323 else if (OSName.startswith("darwin"))
325 else if (OSName.startswith("dragonfly"))
327 else if (OSName.startswith("freebsd"))
329 else if (OSName.startswith("ios"))
331 else if (OSName.startswith("linux"))
333 else if (OSName.startswith("lv2"))
335 else if (OSName.startswith("macosx"))
337 else if (OSName.startswith("mingw32"))
339 else if (OSName.startswith("netbsd"))
341 else if (OSName.startswith("openbsd"))
343 else if (OSName.startswith("psp"))
345 else if (OSName.startswith("solaris"))
347 else if (OSName.startswith("win32"))
349 else if (OSName.startswith("haiku"))
351 else if (OSName.startswith("minix"))
357 Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) {
358 if (EnvironmentName.startswith("eabi"))
360 else if (EnvironmentName.startswith("gnueabi"))
362 else if (EnvironmentName.startswith("gnu"))
364 else if (EnvironmentName.startswith("macho"))
367 return UnknownEnvironment;
370 void Triple::Parse() const {
371 assert(!isInitialized() && "Invalid parse call.");
373 Arch = ParseArch(getArchName());
374 Vendor = ParseVendor(getVendorName());
375 OS = ParseOS(getOSName());
376 Environment = ParseEnvironment(getEnvironmentName());
378 assert(isInitialized() && "Failed to initialize!");
381 std::string Triple::normalize(StringRef Str) {
382 // Parse into components.
383 SmallVector<StringRef, 4> Components;
384 for (size_t First = 0, Last = 0; Last != StringRef::npos; First = Last + 1) {
385 Last = Str.find('-', First);
386 Components.push_back(Str.slice(First, Last));
389 // If the first component corresponds to a known architecture, preferentially
390 // use it for the architecture. If the second component corresponds to a
391 // known vendor, preferentially use it for the vendor, etc. This avoids silly
392 // component movement when a component parses as (eg) both a valid arch and a
394 ArchType Arch = UnknownArch;
395 if (Components.size() > 0)
396 Arch = ParseArch(Components[0]);
397 VendorType Vendor = UnknownVendor;
398 if (Components.size() > 1)
399 Vendor = ParseVendor(Components[1]);
400 OSType OS = UnknownOS;
401 if (Components.size() > 2)
402 OS = ParseOS(Components[2]);
403 EnvironmentType Environment = UnknownEnvironment;
404 if (Components.size() > 3)
405 Environment = ParseEnvironment(Components[3]);
407 // Note which components are already in their final position. These will not
410 Found[0] = Arch != UnknownArch;
411 Found[1] = Vendor != UnknownVendor;
412 Found[2] = OS != UnknownOS;
413 Found[3] = Environment != UnknownEnvironment;
415 // If they are not there already, permute the components into their canonical
416 // positions by seeing if they parse as a valid architecture, and if so moving
417 // the component to the architecture position etc.
418 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
420 continue; // Already in the canonical position.
422 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
423 // Do not reparse any components that already matched.
424 if (Idx < array_lengthof(Found) && Found[Idx])
427 // Does this component parse as valid for the target position?
429 StringRef Comp = Components[Idx];
432 assert(false && "unexpected component type!");
434 Arch = ParseArch(Comp);
435 Valid = Arch != UnknownArch;
438 Vendor = ParseVendor(Comp);
439 Valid = Vendor != UnknownVendor;
443 Valid = OS != UnknownOS;
446 Environment = ParseEnvironment(Comp);
447 Valid = Environment != UnknownEnvironment;
451 continue; // Nope, try the next component.
453 // Move the component to the target position, pushing any non-fixed
454 // components that are in the way to the right. This tends to give
455 // good results in the common cases of a forgotten vendor component
456 // or a wrongly positioned environment.
458 // Insert left, pushing the existing components to the right. For
459 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
460 StringRef CurrentComponent(""); // The empty component.
461 // Replace the component we are moving with an empty component.
462 std::swap(CurrentComponent, Components[Idx]);
463 // Insert the component being moved at Pos, displacing any existing
464 // components to the right.
465 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
466 // Skip over any fixed components.
467 while (i < array_lengthof(Found) && Found[i]) ++i;
468 // Place the component at the new position, getting the component
469 // that was at this position - it will be moved right.
470 std::swap(CurrentComponent, Components[i]);
472 } else if (Pos > Idx) {
473 // Push right by inserting empty components until the component at Idx
474 // reaches the target position Pos. For example, pc-a -> -pc-a when
475 // moving pc to the second position.
477 // Insert one empty component at Idx.
478 StringRef CurrentComponent(""); // The empty component.
479 for (unsigned i = Idx; i < Components.size();) {
480 // Place the component at the new position, getting the component
481 // that was at this position - it will be moved right.
482 std::swap(CurrentComponent, Components[i]);
483 // If it was placed on top of an empty component then we are done.
484 if (CurrentComponent.empty())
486 // Advance to the next component, skipping any fixed components.
487 while (++i < array_lengthof(Found) && Found[i])
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");
548 // Consume the leading digit.
549 Result = Result*10 + (Str[0] - '0');
553 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
558 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
559 unsigned &Micro) const {
560 StringRef OSName = getOSName();
562 // Assume that the OS portion of the triple starts with the canonical name.
563 StringRef OSTypeName = getOSTypeName(getOS());
564 if (OSName.startswith(OSTypeName))
565 OSName = OSName.substr(OSTypeName.size());
567 // Any unset version defaults to 0.
568 Major = Minor = Micro = 0;
570 // Parse up to three components.
571 unsigned *Components[3] = { &Major, &Minor, &Micro };
572 for (unsigned i = 0; i != 3; ++i) {
573 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
576 // Consume the leading number.
577 *Components[i] = EatNumber(OSName);
579 // Consume the separator, if present.
580 if (OSName.startswith("."))
581 OSName = OSName.substr(1);
585 void Triple::setTriple(const Twine &Str) {
590 void Triple::setArch(ArchType Kind) {
591 setArchName(getArchTypeName(Kind));
594 void Triple::setVendor(VendorType Kind) {
595 setVendorName(getVendorTypeName(Kind));
598 void Triple::setOS(OSType Kind) {
599 setOSName(getOSTypeName(Kind));
602 void Triple::setEnvironment(EnvironmentType Kind) {
603 setEnvironmentName(getEnvironmentTypeName(Kind));
606 void Triple::setArchName(StringRef Str) {
607 // Work around a miscompilation bug for Twines in gcc 4.0.3.
608 SmallString<64> Triple;
611 Triple += getVendorName();
613 Triple += getOSAndEnvironmentName();
614 setTriple(Triple.str());
617 void Triple::setVendorName(StringRef Str) {
618 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
621 void Triple::setOSName(StringRef Str) {
622 if (hasEnvironment())
623 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
624 "-" + getEnvironmentName());
626 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
629 void Triple::setEnvironmentName(StringRef Str) {
630 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
634 void Triple::setOSAndEnvironmentName(StringRef Str) {
635 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);