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 SCEI: return "scei";
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 IOS: return "ios";
103 case Linux: return "linux";
104 case Lv2: return "lv2";
105 case MinGW32: return "mingw32";
106 case NetBSD: return "netbsd";
107 case OSX: return "osx";
108 case OpenBSD: return "openbsd";
109 case Psp: return "psp";
110 case Solaris: return "solaris";
111 case Win32: return "win32";
112 case Haiku: return "haiku";
113 case Minix: return "minix";
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 && getOS() != Triple::OSX &&
217 getOS() != Triple::IOS && getVendor() != Triple::Apple)
220 StringRef Str = getArchName();
225 if (Str == "powerpc")
227 if (Str == "powerpc64")
229 if (Str == "mblaze" || Str == "microblaze")
233 if (Str == "armv4t" || Str == "thumbv4t")
235 if (Str == "armv5" || Str == "armv5e" || Str == "thumbv5"
236 || Str == "thumbv5e")
238 if (Str == "armv6" || Str == "thumbv6")
240 if (Str == "armv7" || Str == "thumbv7")
249 Triple::ArchType Triple::ParseArch(StringRef ArchName) {
250 if (ArchName.size() == 4 && ArchName[0] == 'i' &&
251 ArchName[2] == '8' && ArchName[3] == '6' &&
252 ArchName[1] - '3' < 6) // i[3-9]86
254 else if (ArchName == "amd64" || ArchName == "x86_64")
256 else if (ArchName == "bfin")
258 else if (ArchName == "powerpc")
260 else if ((ArchName == "powerpc64") || (ArchName == "ppu"))
262 else if (ArchName == "mblaze")
264 else if (ArchName == "arm" ||
265 ArchName.startswith("armv") ||
266 ArchName == "xscale")
268 else if (ArchName == "thumb" ||
269 ArchName.startswith("thumbv"))
271 else if (ArchName.startswith("alpha"))
273 else if (ArchName == "spu" || ArchName == "cellspu")
275 else if (ArchName == "msp430")
277 else if (ArchName == "mips" || ArchName == "mipsallegrex")
279 else if (ArchName == "mipsel" || ArchName == "mipsallegrexel" ||
282 else if (ArchName == "sparc")
284 else if (ArchName == "sparcv9")
286 else if (ArchName == "s390x")
288 else if (ArchName == "tce")
290 else if (ArchName == "xcore")
292 else if (ArchName == "ptx")
298 Triple::VendorType Triple::ParseVendor(StringRef VendorName) {
299 if (VendorName == "apple")
301 else if (VendorName == "pc")
303 else if (VendorName == "scei")
306 return UnknownVendor;
309 Triple::OSType Triple::ParseOS(StringRef OSName) {
310 if (OSName.startswith("auroraux"))
312 else if (OSName.startswith("cygwin"))
314 else if (OSName.startswith("darwin"))
316 else if (OSName.startswith("dragonfly"))
318 else if (OSName.startswith("freebsd"))
320 else if (OSName.startswith("ios"))
322 else if (OSName.startswith("linux"))
324 else if (OSName.startswith("lv2"))
326 else if (OSName.startswith("mingw32"))
328 else if (OSName.startswith("netbsd"))
330 else if (OSName.startswith("osx"))
332 else if (OSName.startswith("openbsd"))
334 else if (OSName.startswith("psp"))
336 else if (OSName.startswith("solaris"))
338 else if (OSName.startswith("win32"))
340 else if (OSName.startswith("haiku"))
342 else if (OSName.startswith("minix"))
348 Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) {
349 if (EnvironmentName.startswith("eabi"))
351 else if (EnvironmentName.startswith("gnueabi"))
353 else if (EnvironmentName.startswith("gnu"))
355 else if (EnvironmentName.startswith("macho"))
358 return UnknownEnvironment;
361 void Triple::Parse() const {
362 assert(!isInitialized() && "Invalid parse call.");
364 Arch = ParseArch(getArchName());
365 Vendor = ParseVendor(getVendorName());
366 OS = ParseOS(getOSName());
367 Environment = ParseEnvironment(getEnvironmentName());
369 assert(isInitialized() && "Failed to initialize!");
372 std::string Triple::normalize(StringRef Str) {
373 // Parse into components.
374 SmallVector<StringRef, 4> Components;
375 for (size_t First = 0, Last = 0; Last != StringRef::npos; First = Last + 1) {
376 Last = Str.find('-', First);
377 Components.push_back(Str.slice(First, Last));
380 // If the first component corresponds to a known architecture, preferentially
381 // use it for the architecture. If the second component corresponds to a
382 // known vendor, preferentially use it for the vendor, etc. This avoids silly
383 // component movement when a component parses as (eg) both a valid arch and a
385 ArchType Arch = UnknownArch;
386 if (Components.size() > 0)
387 Arch = ParseArch(Components[0]);
388 VendorType Vendor = UnknownVendor;
389 if (Components.size() > 1)
390 Vendor = ParseVendor(Components[1]);
391 OSType OS = UnknownOS;
392 if (Components.size() > 2)
393 OS = ParseOS(Components[2]);
394 EnvironmentType Environment = UnknownEnvironment;
395 if (Components.size() > 3)
396 Environment = ParseEnvironment(Components[3]);
398 // Note which components are already in their final position. These will not
401 Found[0] = Arch != UnknownArch;
402 Found[1] = Vendor != UnknownVendor;
403 Found[2] = OS != UnknownOS;
404 Found[3] = Environment != UnknownEnvironment;
406 // If they are not there already, permute the components into their canonical
407 // positions by seeing if they parse as a valid architecture, and if so moving
408 // the component to the architecture position etc.
409 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
411 continue; // Already in the canonical position.
413 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
414 // Do not reparse any components that already matched.
415 if (Idx < array_lengthof(Found) && Found[Idx])
418 // Does this component parse as valid for the target position?
420 StringRef Comp = Components[Idx];
423 assert(false && "unexpected component type!");
425 Arch = ParseArch(Comp);
426 Valid = Arch != UnknownArch;
429 Vendor = ParseVendor(Comp);
430 Valid = Vendor != UnknownVendor;
434 Valid = OS != UnknownOS;
437 Environment = ParseEnvironment(Comp);
438 Valid = Environment != UnknownEnvironment;
442 continue; // Nope, try the next component.
444 // Move the component to the target position, pushing any non-fixed
445 // components that are in the way to the right. This tends to give
446 // good results in the common cases of a forgotten vendor component
447 // or a wrongly positioned environment.
449 // Insert left, pushing the existing components to the right. For
450 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
451 StringRef CurrentComponent(""); // The empty component.
452 // Replace the component we are moving with an empty component.
453 std::swap(CurrentComponent, Components[Idx]);
454 // Insert the component being moved at Pos, displacing any existing
455 // components to the right.
456 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
457 // Skip over any fixed components.
458 while (i < array_lengthof(Found) && Found[i]) ++i;
459 // Place the component at the new position, getting the component
460 // that was at this position - it will be moved right.
461 std::swap(CurrentComponent, Components[i]);
463 } else if (Pos > Idx) {
464 // Push right by inserting empty components until the component at Idx
465 // reaches the target position Pos. For example, pc-a -> -pc-a when
466 // moving pc to the second position.
468 // Insert one empty component at Idx.
469 StringRef CurrentComponent(""); // The empty component.
470 for (unsigned i = Idx; i < Components.size();) {
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]);
474 // If it was placed on top of an empty component then we are done.
475 if (CurrentComponent.empty())
477 // Advance to the next component, skipping any fixed components.
478 while (++i < array_lengthof(Found) && Found[i])
481 // The last component was pushed off the end - append it.
482 if (!CurrentComponent.empty())
483 Components.push_back(CurrentComponent);
485 // Advance Idx to the component's new position.
486 while (++Idx < array_lengthof(Found) && Found[Idx]) {}
487 } while (Idx < Pos); // Add more until the final position is reached.
489 assert(Pos < Components.size() && Components[Pos] == Comp &&
490 "Component moved wrong!");
496 // Special case logic goes here. At this point Arch, Vendor and OS have the
497 // correct values for the computed components.
499 // Stick the corrected components back together to form the normalized string.
500 std::string Normalized;
501 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
502 if (i) Normalized += '-';
503 Normalized += Components[i];
508 StringRef Triple::getArchName() const {
509 return StringRef(Data).split('-').first; // Isolate first component
512 StringRef Triple::getVendorName() const {
513 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
514 return Tmp.split('-').first; // Isolate second component
517 StringRef Triple::getOSName() const {
518 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
519 Tmp = Tmp.split('-').second; // Strip second component
520 return Tmp.split('-').first; // Isolate third component
523 StringRef Triple::getEnvironmentName() const {
524 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
525 Tmp = Tmp.split('-').second; // Strip second component
526 return Tmp.split('-').second; // Strip third component
529 StringRef Triple::getOSAndEnvironmentName() const {
530 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
531 return Tmp.split('-').second; // Strip second component
534 static unsigned EatNumber(StringRef &Str) {
535 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
539 // Consume the leading digit.
540 Result = Result*10 + (Str[0] - '0');
544 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
549 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
550 unsigned &Micro) const {
551 StringRef OSName = getOSName();
553 // Assume that the OS portion of the triple starts with the canonical name.
554 StringRef OSTypeName = getOSTypeName(getOS());
555 if (OSName.startswith(OSTypeName))
556 OSName = OSName.substr(OSTypeName.size());
558 // Any unset version defaults to 0.
559 Major = Minor = Micro = 0;
561 // Parse up to three components.
562 unsigned *Components[3] = { &Major, &Minor, &Micro };
563 for (unsigned i = 0; i != 3; ++i) {
564 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
567 // Consume the leading number.
568 *Components[i] = EatNumber(OSName);
570 // Consume the separator, if present.
571 if (OSName.startswith("."))
572 OSName = OSName.substr(1);
576 void Triple::setTriple(const Twine &Str) {
581 void Triple::setArch(ArchType Kind) {
582 setArchName(getArchTypeName(Kind));
585 void Triple::setVendor(VendorType Kind) {
586 setVendorName(getVendorTypeName(Kind));
589 void Triple::setOS(OSType Kind) {
590 setOSName(getOSTypeName(Kind));
593 void Triple::setEnvironment(EnvironmentType Kind) {
594 setEnvironmentName(getEnvironmentTypeName(Kind));
597 void Triple::setArchName(StringRef Str) {
598 // Work around a miscompilation bug for Twines in gcc 4.0.3.
599 SmallString<64> Triple;
602 Triple += getVendorName();
604 Triple += getOSAndEnvironmentName();
605 setTriple(Triple.str());
608 void Triple::setVendorName(StringRef Str) {
609 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
612 void Triple::setOSName(StringRef Str) {
613 if (hasEnvironment())
614 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
615 "-" + getEnvironmentName());
617 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
620 void Triple::setEnvironmentName(StringRef Str) {
621 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
625 void Triple::setOSAndEnvironmentName(StringRef Str) {
626 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);