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";
92 const char *Triple::getOSTypeName(OSType Kind) {
94 case UnknownOS: return "unknown";
96 case AuroraUX: return "auroraux";
97 case Cygwin: return "cygwin";
98 case Darwin: return "darwin";
99 case DragonFly: return "dragonfly";
100 case FreeBSD: return "freebsd";
101 case Linux: return "linux";
102 case Lv2: return "lv2";
103 case MinGW32: return "mingw32";
104 case MinGW64: return "mingw64";
105 case NetBSD: return "netbsd";
106 case OpenBSD: return "openbsd";
107 case Psp: return "psp";
108 case Solaris: return "solaris";
109 case Win32: return "win32";
110 case Haiku: return "haiku";
111 case Minix: return "minix";
117 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
119 case UnknownEnvironment: return "unknown";
120 case GNU: return "gnu";
121 case GNUEABI: return "gnueabi";
122 case EABI: return "eabi";
123 case MachO: return "macho";
129 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
136 if (Name == "cellspu")
140 if (Name == "mipsel")
142 if (Name == "msp430")
148 if (Name == "mblaze")
152 if (Name == "sparcv9")
154 if (Name == "systemz")
162 if (Name == "x86-64")
172 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
173 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
174 // archs which Darwin doesn't use.
176 // The matching this routine does is fairly pointless, since it is neither the
177 // complete architecture list, nor a reasonable subset. The problem is that
178 // historically the driver driver accepts this and also ties its -march=
179 // handling to the architecture name, so we need to be careful before removing
182 // This code must be kept in sync with Clang's Darwin specific argument
185 if (Str == "ppc" || Str == "ppc601" || Str == "ppc603" || Str == "ppc604" ||
186 Str == "ppc604e" || Str == "ppc750" || Str == "ppc7400" ||
187 Str == "ppc7450" || Str == "ppc970")
191 return Triple::ppc64;
193 if (Str == "i386" || Str == "i486" || Str == "i486SX" || Str == "pentium" ||
194 Str == "i586" || Str == "pentpro" || Str == "i686" || Str == "pentIIm3" ||
195 Str == "pentIIm5" || Str == "pentium4")
199 return Triple::x86_64;
201 // This is derived from the driver driver.
202 if (Str == "arm" || Str == "armv4t" || Str == "armv5" || Str == "xscale" ||
203 Str == "armv6" || Str == "armv7")
209 return Triple::UnknownArch;
212 // Returns architecture name that is understood by the target assembler.
213 const char *Triple::getArchNameForAssembler() {
214 if (getOS() != Triple::Darwin && getVendor() != Triple::Apple)
217 StringRef Str = getArchName();
222 if (Str == "powerpc")
224 if (Str == "powerpc64")
226 if (Str == "mblaze" || Str == "microblaze")
230 if (Str == "armv4t" || Str == "thumbv4t")
232 if (Str == "armv5" || Str == "armv5e" || Str == "thumbv5"
233 || Str == "thumbv5e")
235 if (Str == "armv6" || Str == "thumbv6")
237 if (Str == "armv7" || Str == "thumbv7")
246 Triple::ArchType Triple::ParseArch(StringRef ArchName) {
247 if (ArchName.size() == 4 && ArchName[0] == 'i' &&
248 ArchName[2] == '8' && ArchName[3] == '6' &&
249 ArchName[1] - '3' < 6) // i[3-9]86
251 else if (ArchName == "amd64" || ArchName == "x86_64")
253 else if (ArchName == "bfin")
255 else if (ArchName == "powerpc")
257 else if ((ArchName == "powerpc64") || (ArchName == "ppu"))
259 else if (ArchName == "mblaze")
261 else if (ArchName == "arm" ||
262 ArchName.startswith("armv") ||
263 ArchName == "xscale")
265 else if (ArchName == "thumb" ||
266 ArchName.startswith("thumbv"))
268 else if (ArchName.startswith("alpha"))
270 else if (ArchName == "spu" || ArchName == "cellspu")
272 else if (ArchName == "msp430")
274 else if (ArchName == "mips" || ArchName == "mipsallegrex")
276 else if (ArchName == "mipsel" || ArchName == "mipsallegrexel" ||
279 else if (ArchName == "sparc")
281 else if (ArchName == "sparcv9")
283 else if (ArchName == "s390x")
285 else if (ArchName == "tce")
287 else if (ArchName == "xcore")
289 else if (ArchName == "ptx")
295 Triple::VendorType Triple::ParseVendor(StringRef VendorName) {
296 if (VendorName == "apple")
298 else if (VendorName == "pc")
301 return UnknownVendor;
304 Triple::OSType Triple::ParseOS(StringRef OSName) {
305 if (OSName.startswith("auroraux"))
307 else if (OSName.startswith("cygwin"))
309 else if (OSName.startswith("darwin"))
311 else if (OSName.startswith("dragonfly"))
313 else if (OSName.startswith("freebsd"))
315 else if (OSName.startswith("linux"))
317 else if (OSName.startswith("lv2"))
319 else if (OSName.startswith("mingw32"))
321 else if (OSName.startswith("mingw64"))
323 else if (OSName.startswith("netbsd"))
325 else if (OSName.startswith("openbsd"))
327 else if (OSName.startswith("psp"))
329 else if (OSName.startswith("solaris"))
331 else if (OSName.startswith("win32"))
333 else if (OSName.startswith("haiku"))
335 else if (OSName.startswith("minix"))
341 Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) {
342 if (EnvironmentName.startswith("eabi"))
344 else if (EnvironmentName.startswith("gnueabi"))
346 else if (EnvironmentName.startswith("gnu"))
348 else if (EnvironmentName.startswith("macho"))
351 return UnknownEnvironment;
354 void Triple::Parse() const {
355 assert(!isInitialized() && "Invalid parse call.");
357 Arch = ParseArch(getArchName());
358 Vendor = ParseVendor(getVendorName());
359 OS = ParseOS(getOSName());
360 Environment = ParseEnvironment(getEnvironmentName());
362 assert(isInitialized() && "Failed to initialize!");
365 std::string Triple::normalize(StringRef Str) {
366 // Parse into components.
367 SmallVector<StringRef, 4> Components;
368 for (size_t First = 0, Last = 0; Last != StringRef::npos; First = Last + 1) {
369 Last = Str.find('-', First);
370 Components.push_back(Str.slice(First, Last));
373 // If the first component corresponds to a known architecture, preferentially
374 // use it for the architecture. If the second component corresponds to a
375 // known vendor, preferentially use it for the vendor, etc. This avoids silly
376 // component movement when a component parses as (eg) both a valid arch and a
378 ArchType Arch = UnknownArch;
379 if (Components.size() > 0)
380 Arch = ParseArch(Components[0]);
381 VendorType Vendor = UnknownVendor;
382 if (Components.size() > 1)
383 Vendor = ParseVendor(Components[1]);
384 OSType OS = UnknownOS;
385 if (Components.size() > 2)
386 OS = ParseOS(Components[2]);
387 EnvironmentType Environment = UnknownEnvironment;
388 if (Components.size() > 3)
389 Environment = ParseEnvironment(Components[3]);
391 // Note which components are already in their final position. These will not
394 Found[0] = Arch != UnknownArch;
395 Found[1] = Vendor != UnknownVendor;
396 Found[2] = OS != UnknownOS;
397 Found[3] = Environment != UnknownEnvironment;
399 // If they are not there already, permute the components into their canonical
400 // positions by seeing if they parse as a valid architecture, and if so moving
401 // the component to the architecture position etc.
402 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
404 continue; // Already in the canonical position.
406 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
407 // Do not reparse any components that already matched.
408 if (Idx < array_lengthof(Found) && Found[Idx])
411 // Does this component parse as valid for the target position?
413 StringRef Comp = Components[Idx];
416 assert(false && "unexpected component type!");
418 Arch = ParseArch(Comp);
419 Valid = Arch != UnknownArch;
422 Vendor = ParseVendor(Comp);
423 Valid = Vendor != UnknownVendor;
427 Valid = OS != UnknownOS;
430 Environment = ParseEnvironment(Comp);
431 Valid = Environment != UnknownEnvironment;
435 continue; // Nope, try the next component.
437 // Move the component to the target position, pushing any non-fixed
438 // components that are in the way to the right. This tends to give
439 // good results in the common cases of a forgotten vendor component
440 // or a wrongly positioned environment.
442 // Insert left, pushing the existing components to the right. For
443 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
444 StringRef CurrentComponent(""); // The empty component.
445 // Replace the component we are moving with an empty component.
446 std::swap(CurrentComponent, Components[Idx]);
447 // Insert the component being moved at Pos, displacing any existing
448 // components to the right.
449 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
450 // Skip over any fixed components.
451 while (i < array_lengthof(Found) && Found[i]) ++i;
452 // Place the component at the new position, getting the component
453 // that was at this position - it will be moved right.
454 std::swap(CurrentComponent, Components[i]);
456 } else if (Pos > Idx) {
457 // Push right by inserting empty components until the component at Idx
458 // reaches the target position Pos. For example, pc-a -> -pc-a when
459 // moving pc to the second position.
461 // Insert one empty component at Idx.
462 StringRef CurrentComponent(""); // The empty component.
463 for (unsigned i = Idx; i < Components.size();) {
464 // Place the component at the new position, getting the component
465 // that was at this position - it will be moved right.
466 std::swap(CurrentComponent, Components[i]);
467 // If it was placed on top of an empty component then we are done.
468 if (CurrentComponent.empty())
470 // Advance to the next component, skipping any fixed components.
471 while (++i < array_lengthof(Found) && Found[i]);
473 // The last component was pushed off the end - append it.
474 if (!CurrentComponent.empty())
475 Components.push_back(CurrentComponent);
477 // Advance Idx to the component's new position.
478 while (++Idx < array_lengthof(Found) && Found[Idx]) {}
479 } while (Idx < Pos); // Add more until the final position is reached.
481 assert(Pos < Components.size() && Components[Pos] == Comp &&
482 "Component moved wrong!");
488 // Special case logic goes here. At this point Arch, Vendor and OS have the
489 // correct values for the computed components.
491 // Stick the corrected components back together to form the normalized string.
492 std::string Normalized;
493 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
494 if (i) Normalized += '-';
495 Normalized += Components[i];
500 StringRef Triple::getArchName() const {
501 return StringRef(Data).split('-').first; // Isolate first component
504 StringRef Triple::getVendorName() const {
505 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
506 return Tmp.split('-').first; // Isolate second component
509 StringRef Triple::getOSName() const {
510 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
511 Tmp = Tmp.split('-').second; // Strip second component
512 return Tmp.split('-').first; // Isolate third component
515 StringRef Triple::getEnvironmentName() const {
516 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
517 Tmp = Tmp.split('-').second; // Strip second component
518 return Tmp.split('-').second; // Strip third component
521 StringRef Triple::getOSAndEnvironmentName() const {
522 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
523 return Tmp.split('-').second; // Strip second component
526 static unsigned EatNumber(StringRef &Str) {
527 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
528 unsigned Result = Str[0]-'0';
533 // Handle "darwin11".
534 if (Result == 1 && !Str.empty() && Str[0] >= '0' && Str[0] <= '9') {
535 Result = Result*10 + (Str[0] - '0');
543 /// getDarwinNumber - Parse the 'darwin number' out of the specific target
544 /// triple. For example, if we have darwin8.5 return 8,5,0. If any entry is
545 /// not defined, return 0's. This requires that the triple have an OSType of
546 /// darwin before it is called.
547 void Triple::getDarwinNumber(unsigned &Maj, unsigned &Min,
548 unsigned &Revision) const {
549 assert(getOS() == Darwin && "Not a darwin target triple!");
550 StringRef OSName = getOSName();
551 assert(OSName.startswith("darwin") && "Unknown darwin target triple!");
553 // Strip off "darwin".
554 OSName = OSName.substr(6);
556 Maj = Min = Revision = 0;
558 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
561 // The major version is the first digit.
562 Maj = EatNumber(OSName);
563 if (OSName.empty()) return;
565 // Handle minor version: 10.4.9 -> darwin8.9.
566 if (OSName[0] != '.')
570 OSName = OSName.substr(1);
572 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
575 Min = EatNumber(OSName);
576 if (OSName.empty()) return;
578 // Handle revision darwin8.9.1
579 if (OSName[0] != '.')
583 OSName = OSName.substr(1);
585 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
588 Revision = EatNumber(OSName);
591 void Triple::setTriple(const Twine &Str) {
596 void Triple::setArch(ArchType Kind) {
597 setArchName(getArchTypeName(Kind));
600 void Triple::setVendor(VendorType Kind) {
601 setVendorName(getVendorTypeName(Kind));
604 void Triple::setOS(OSType Kind) {
605 setOSName(getOSTypeName(Kind));
608 void Triple::setEnvironment(EnvironmentType Kind) {
609 setEnvironmentName(getEnvironmentTypeName(Kind));
612 void Triple::setArchName(StringRef Str) {
613 // Work around a miscompilation bug for Twines in gcc 4.0.3.
614 SmallString<64> Triple;
617 Triple += getVendorName();
619 Triple += getOSAndEnvironmentName();
620 setTriple(Triple.str());
623 void Triple::setVendorName(StringRef Str) {
624 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
627 void Triple::setOSName(StringRef Str) {
628 if (hasEnvironment())
629 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
630 "-" + getEnvironmentName());
632 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
635 void Triple::setEnvironmentName(StringRef Str) {
636 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
640 void Triple::setOSAndEnvironmentName(StringRef Str) {
641 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);