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"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringSwitch.h"
14 #include "llvm/Support/ErrorHandling.h"
18 const char *Triple::getArchTypeName(ArchType Kind) {
20 case UnknownArch: return "unknown";
22 case aarch64: return "aarch64";
23 case arm: return "arm";
24 case hexagon: return "hexagon";
25 case mips: return "mips";
26 case mipsel: return "mipsel";
27 case mips64: return "mips64";
28 case mips64el:return "mips64el";
29 case msp430: return "msp430";
30 case ppc64: return "powerpc64";
31 case ppc64le: return "powerpc64le";
32 case ppc: return "powerpc";
33 case r600: return "r600";
34 case sparc: return "sparc";
35 case sparcv9: return "sparcv9";
36 case systemz: return "s390x";
37 case tce: return "tce";
38 case thumb: return "thumb";
39 case x86: return "i386";
40 case x86_64: return "x86_64";
41 case xcore: return "xcore";
42 case nvptx: return "nvptx";
43 case nvptx64: return "nvptx64";
44 case le32: return "le32";
45 case amdil: return "amdil";
46 case spir: return "spir";
47 case spir64: return "spir64";
50 llvm_unreachable("Invalid ArchType!");
53 const char *Triple::getArchTypePrefix(ArchType Kind) {
58 case aarch64: return "aarch64";
61 case thumb: return "arm";
65 case ppc: return "ppc";
70 case mips64el:return "mips";
72 case hexagon: return "hexagon";
74 case r600: return "r600";
77 case sparc: return "sparc";
79 case systemz: return "systemz";
82 case x86_64: return "x86";
84 case xcore: return "xcore";
86 case nvptx: return "nvptx";
87 case nvptx64: return "nvptx";
88 case le32: return "le32";
89 case amdil: return "amdil";
90 case spir: return "spir";
91 case spir64: return "spir";
95 const char *Triple::getVendorTypeName(VendorType Kind) {
97 case UnknownVendor: return "unknown";
99 case Apple: return "apple";
100 case PC: return "pc";
101 case SCEI: return "scei";
102 case BGP: return "bgp";
103 case BGQ: return "bgq";
104 case Freescale: return "fsl";
105 case IBM: return "ibm";
106 case NVIDIA: return "nvidia";
109 llvm_unreachable("Invalid VendorType!");
112 const char *Triple::getOSTypeName(OSType Kind) {
114 case UnknownOS: return "unknown";
116 case AuroraUX: return "auroraux";
117 case Cygwin: return "cygwin";
118 case Darwin: return "darwin";
119 case DragonFly: return "dragonfly";
120 case FreeBSD: return "freebsd";
121 case IOS: return "ios";
122 case KFreeBSD: return "kfreebsd";
123 case Linux: return "linux";
124 case Lv2: return "lv2";
125 case MacOSX: return "macosx";
126 case MinGW32: return "mingw32";
127 case NetBSD: return "netbsd";
128 case OpenBSD: return "openbsd";
129 case Solaris: return "solaris";
130 case Win32: return "win32";
131 case Haiku: return "haiku";
132 case Minix: return "minix";
133 case RTEMS: return "rtems";
134 case NaCl: return "nacl";
135 case CNK: return "cnk";
136 case Bitrig: return "bitrig";
137 case AIX: return "aix";
138 case CUDA: return "cuda";
139 case NVCL: return "nvcl";
142 llvm_unreachable("Invalid OSType");
145 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
147 case UnknownEnvironment: return "unknown";
148 case GNU: return "gnu";
149 case GNUEABIHF: return "gnueabihf";
150 case GNUEABI: return "gnueabi";
151 case GNUX32: return "gnux32";
152 case EABI: return "eabi";
153 case EABIHF: return "eabihf";
154 case MachO: return "macho";
155 case Android: return "android";
156 case ELF: return "elf";
159 llvm_unreachable("Invalid EnvironmentType!");
162 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
163 return StringSwitch<Triple::ArchType>(Name)
164 .Case("aarch64", aarch64)
167 .Case("mipsel", mipsel)
168 .Case("mips64", mips64)
169 .Case("mips64el", mips64el)
170 .Case("msp430", msp430)
171 .Case("ppc64", ppc64)
174 .Case("ppc64le", ppc64le)
176 .Case("hexagon", hexagon)
177 .Case("sparc", sparc)
178 .Case("sparcv9", sparcv9)
179 .Case("systemz", systemz)
181 .Case("thumb", thumb)
183 .Case("x86-64", x86_64)
184 .Case("xcore", xcore)
185 .Case("nvptx", nvptx)
186 .Case("nvptx64", nvptx64)
188 .Case("amdil", amdil)
190 .Case("spir64", spir64)
191 .Default(UnknownArch);
194 // Returns architecture name that is understood by the target assembler.
195 const char *Triple::getArchNameForAssembler() {
196 if (!isOSDarwin() && getVendor() != Triple::Apple)
199 return StringSwitch<const char*>(getArchName())
200 .Case("i386", "i386")
201 .Case("x86_64", "x86_64")
202 .Case("powerpc", "ppc")
203 .Case("powerpc64", "ppc64")
204 .Case("powerpc64le", "ppc64le")
206 .Cases("armv4t", "thumbv4t", "armv4t")
207 .Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5")
208 .Cases("armv6", "thumbv6", "armv6")
209 .Cases("armv7", "thumbv7", "armv7")
210 .Case("r600", "r600")
211 .Case("nvptx", "nvptx")
212 .Case("nvptx64", "nvptx64")
213 .Case("le32", "le32")
214 .Case("amdil", "amdil")
215 .Case("spir", "spir")
216 .Case("spir64", "spir64")
220 static Triple::ArchType parseArch(StringRef ArchName) {
221 return StringSwitch<Triple::ArchType>(ArchName)
222 .Cases("i386", "i486", "i586", "i686", Triple::x86)
223 // FIXME: Do we need to support these?
224 .Cases("i786", "i886", "i986", Triple::x86)
225 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
226 .Case("powerpc", Triple::ppc)
227 .Cases("powerpc64", "ppu", Triple::ppc64)
228 .Case("powerpc64le", Triple::ppc64le)
229 .Case("aarch64", Triple::aarch64)
230 .Cases("arm", "xscale", Triple::arm)
231 // FIXME: It would be good to replace these with explicit names for all the
232 // various suffixes supported.
233 .StartsWith("armv", Triple::arm)
234 .Case("thumb", Triple::thumb)
235 .StartsWith("thumbv", Triple::thumb)
236 .Case("msp430", Triple::msp430)
237 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
238 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
239 .Cases("mips64", "mips64eb", Triple::mips64)
240 .Case("mips64el", Triple::mips64el)
241 .Case("r600", Triple::r600)
242 .Case("hexagon", Triple::hexagon)
243 .Case("s390x", Triple::systemz)
244 .Case("sparc", Triple::sparc)
245 .Cases("sparcv9", "sparc64", Triple::sparcv9)
246 .Case("tce", Triple::tce)
247 .Case("xcore", Triple::xcore)
248 .Case("nvptx", Triple::nvptx)
249 .Case("nvptx64", Triple::nvptx64)
250 .Case("le32", Triple::le32)
251 .Case("amdil", Triple::amdil)
252 .Case("spir", Triple::spir)
253 .Case("spir64", Triple::spir64)
254 .Default(Triple::UnknownArch);
257 static Triple::VendorType parseVendor(StringRef VendorName) {
258 return StringSwitch<Triple::VendorType>(VendorName)
259 .Case("apple", Triple::Apple)
260 .Case("pc", Triple::PC)
261 .Case("scei", Triple::SCEI)
262 .Case("bgp", Triple::BGP)
263 .Case("bgq", Triple::BGQ)
264 .Case("fsl", Triple::Freescale)
265 .Case("ibm", Triple::IBM)
266 .Case("nvidia", Triple::NVIDIA)
267 .Default(Triple::UnknownVendor);
270 static Triple::OSType parseOS(StringRef OSName) {
271 return StringSwitch<Triple::OSType>(OSName)
272 .StartsWith("auroraux", Triple::AuroraUX)
273 .StartsWith("cygwin", Triple::Cygwin)
274 .StartsWith("darwin", Triple::Darwin)
275 .StartsWith("dragonfly", Triple::DragonFly)
276 .StartsWith("freebsd", Triple::FreeBSD)
277 .StartsWith("ios", Triple::IOS)
278 .StartsWith("kfreebsd", Triple::KFreeBSD)
279 .StartsWith("linux", Triple::Linux)
280 .StartsWith("lv2", Triple::Lv2)
281 .StartsWith("macosx", Triple::MacOSX)
282 .StartsWith("mingw32", Triple::MinGW32)
283 .StartsWith("netbsd", Triple::NetBSD)
284 .StartsWith("openbsd", Triple::OpenBSD)
285 .StartsWith("solaris", Triple::Solaris)
286 .StartsWith("win32", Triple::Win32)
287 .StartsWith("haiku", Triple::Haiku)
288 .StartsWith("minix", Triple::Minix)
289 .StartsWith("rtems", Triple::RTEMS)
290 .StartsWith("nacl", Triple::NaCl)
291 .StartsWith("cnk", Triple::CNK)
292 .StartsWith("bitrig", Triple::Bitrig)
293 .StartsWith("aix", Triple::AIX)
294 .StartsWith("cuda", Triple::CUDA)
295 .StartsWith("nvcl", Triple::NVCL)
296 .Default(Triple::UnknownOS);
299 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
300 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
301 .StartsWith("eabihf", Triple::EABIHF)
302 .StartsWith("eabi", Triple::EABI)
303 .StartsWith("gnueabihf", Triple::GNUEABIHF)
304 .StartsWith("gnueabi", Triple::GNUEABI)
305 .StartsWith("gnux32", Triple::GNUX32)
306 .StartsWith("gnu", Triple::GNU)
307 .StartsWith("macho", Triple::MachO)
308 .StartsWith("android", Triple::Android)
309 .StartsWith("elf", Triple::ELF)
310 .Default(Triple::UnknownEnvironment);
313 /// \brief Construct a triple from the string representation provided.
315 /// This stores the string representation and parses the various pieces into
317 Triple::Triple(const Twine &Str)
319 Arch(parseArch(getArchName())),
320 Vendor(parseVendor(getVendorName())),
321 OS(parseOS(getOSName())),
322 Environment(parseEnvironment(getEnvironmentName())) {
325 /// \brief Construct a triple from string representations of the architecture,
328 /// This joins each argument into a canonical string representation and parses
329 /// them into enum members. It leaves the environment unknown and omits it from
330 /// the string representation.
331 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
332 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
333 Arch(parseArch(ArchStr.str())),
334 Vendor(parseVendor(VendorStr.str())),
335 OS(parseOS(OSStr.str())),
339 /// \brief Construct a triple from string representations of the architecture,
340 /// vendor, OS, and environment.
342 /// This joins each argument into a canonical string representation and parses
343 /// them into enum members.
344 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
345 const Twine &EnvironmentStr)
346 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
347 EnvironmentStr).str()),
348 Arch(parseArch(ArchStr.str())),
349 Vendor(parseVendor(VendorStr.str())),
350 OS(parseOS(OSStr.str())),
351 Environment(parseEnvironment(EnvironmentStr.str())) {
354 std::string Triple::normalize(StringRef Str) {
355 // Parse into components.
356 SmallVector<StringRef, 4> Components;
357 Str.split(Components, "-");
359 // If the first component corresponds to a known architecture, preferentially
360 // use it for the architecture. If the second component corresponds to a
361 // known vendor, preferentially use it for the vendor, etc. This avoids silly
362 // component movement when a component parses as (eg) both a valid arch and a
364 ArchType Arch = UnknownArch;
365 if (Components.size() > 0)
366 Arch = parseArch(Components[0]);
367 VendorType Vendor = UnknownVendor;
368 if (Components.size() > 1)
369 Vendor = parseVendor(Components[1]);
370 OSType OS = UnknownOS;
371 if (Components.size() > 2)
372 OS = parseOS(Components[2]);
373 EnvironmentType Environment = UnknownEnvironment;
374 if (Components.size() > 3)
375 Environment = parseEnvironment(Components[3]);
377 // Note which components are already in their final position. These will not
380 Found[0] = Arch != UnknownArch;
381 Found[1] = Vendor != UnknownVendor;
382 Found[2] = OS != UnknownOS;
383 Found[3] = Environment != UnknownEnvironment;
385 // If they are not there already, permute the components into their canonical
386 // positions by seeing if they parse as a valid architecture, and if so moving
387 // the component to the architecture position etc.
388 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
390 continue; // Already in the canonical position.
392 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
393 // Do not reparse any components that already matched.
394 if (Idx < array_lengthof(Found) && Found[Idx])
397 // Does this component parse as valid for the target position?
399 StringRef Comp = Components[Idx];
401 default: llvm_unreachable("unexpected component type!");
403 Arch = parseArch(Comp);
404 Valid = Arch != UnknownArch;
407 Vendor = parseVendor(Comp);
408 Valid = Vendor != UnknownVendor;
412 Valid = OS != UnknownOS;
415 Environment = parseEnvironment(Comp);
416 Valid = Environment != UnknownEnvironment;
420 continue; // Nope, try the next component.
422 // Move the component to the target position, pushing any non-fixed
423 // components that are in the way to the right. This tends to give
424 // good results in the common cases of a forgotten vendor component
425 // or a wrongly positioned environment.
427 // Insert left, pushing the existing components to the right. For
428 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
429 StringRef CurrentComponent(""); // The empty component.
430 // Replace the component we are moving with an empty component.
431 std::swap(CurrentComponent, Components[Idx]);
432 // Insert the component being moved at Pos, displacing any existing
433 // components to the right.
434 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
435 // Skip over any fixed components.
436 while (i < array_lengthof(Found) && Found[i])
438 // Place the component at the new position, getting the component
439 // that was at this position - it will be moved right.
440 std::swap(CurrentComponent, Components[i]);
442 } else if (Pos > Idx) {
443 // Push right by inserting empty components until the component at Idx
444 // reaches the target position Pos. For example, pc-a -> -pc-a when
445 // moving pc to the second position.
447 // Insert one empty component at Idx.
448 StringRef CurrentComponent(""); // The empty component.
449 for (unsigned i = Idx; i < Components.size();) {
450 // Place the component at the new position, getting the component
451 // that was at this position - it will be moved right.
452 std::swap(CurrentComponent, Components[i]);
453 // If it was placed on top of an empty component then we are done.
454 if (CurrentComponent.empty())
456 // Advance to the next component, skipping any fixed components.
457 while (++i < array_lengthof(Found) && Found[i])
460 // The last component was pushed off the end - append it.
461 if (!CurrentComponent.empty())
462 Components.push_back(CurrentComponent);
464 // Advance Idx to the component's new position.
465 while (++Idx < array_lengthof(Found) && Found[Idx])
467 } while (Idx < Pos); // Add more until the final position is reached.
469 assert(Pos < Components.size() && Components[Pos] == Comp &&
470 "Component moved wrong!");
476 // Special case logic goes here. At this point Arch, Vendor and OS have the
477 // correct values for the computed components.
479 // Stick the corrected components back together to form the normalized string.
480 std::string Normalized;
481 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
482 if (i) Normalized += '-';
483 Normalized += Components[i];
488 StringRef Triple::getArchName() const {
489 return StringRef(Data).split('-').first; // Isolate first component
492 StringRef Triple::getVendorName() const {
493 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
494 return Tmp.split('-').first; // Isolate second component
497 StringRef Triple::getOSName() const {
498 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
499 Tmp = Tmp.split('-').second; // Strip second component
500 return Tmp.split('-').first; // Isolate third component
503 StringRef Triple::getEnvironmentName() const {
504 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
505 Tmp = Tmp.split('-').second; // Strip second component
506 return Tmp.split('-').second; // Strip third component
509 StringRef Triple::getOSAndEnvironmentName() const {
510 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
511 return Tmp.split('-').second; // Strip second component
514 static unsigned EatNumber(StringRef &Str) {
515 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
519 // Consume the leading digit.
520 Result = Result*10 + (Str[0] - '0');
524 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
529 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
530 unsigned &Micro) const {
531 StringRef OSName = getOSName();
533 // Assume that the OS portion of the triple starts with the canonical name.
534 StringRef OSTypeName = getOSTypeName(getOS());
535 if (OSName.startswith(OSTypeName))
536 OSName = OSName.substr(OSTypeName.size());
538 // Any unset version defaults to 0.
539 Major = Minor = Micro = 0;
541 // Parse up to three components.
542 unsigned *Components[3] = { &Major, &Minor, &Micro };
543 for (unsigned i = 0; i != 3; ++i) {
544 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
547 // Consume the leading number.
548 *Components[i] = EatNumber(OSName);
550 // Consume the separator, if present.
551 if (OSName.startswith("."))
552 OSName = OSName.substr(1);
556 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
557 unsigned &Micro) const {
558 getOSVersion(Major, Minor, Micro);
561 default: llvm_unreachable("unexpected OS for Darwin triple");
563 // Default to darwin8, i.e., MacOSX 10.4.
566 // Darwin version numbers are skewed from OS X versions.
583 // Ignore the version from the triple. This is only handled because the
584 // the clang driver combines OS X and IOS support into a common Darwin
585 // toolchain that wants to know the OS X version number even when targeting
595 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
596 unsigned &Micro) const {
598 default: llvm_unreachable("unexpected OS for Darwin triple");
601 // Ignore the version from the triple. This is only handled because the
602 // the clang driver combines OS X and IOS support into a common Darwin
603 // toolchain that wants to know the iOS version number even when targeting
610 getOSVersion(Major, Minor, Micro);
618 void Triple::setTriple(const Twine &Str) {
622 void Triple::setArch(ArchType Kind) {
623 setArchName(getArchTypeName(Kind));
626 void Triple::setVendor(VendorType Kind) {
627 setVendorName(getVendorTypeName(Kind));
630 void Triple::setOS(OSType Kind) {
631 setOSName(getOSTypeName(Kind));
634 void Triple::setEnvironment(EnvironmentType Kind) {
635 setEnvironmentName(getEnvironmentTypeName(Kind));
638 void Triple::setArchName(StringRef Str) {
639 // Work around a miscompilation bug for Twines in gcc 4.0.3.
640 SmallString<64> Triple;
643 Triple += getVendorName();
645 Triple += getOSAndEnvironmentName();
646 setTriple(Triple.str());
649 void Triple::setVendorName(StringRef Str) {
650 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
653 void Triple::setOSName(StringRef Str) {
654 if (hasEnvironment())
655 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
656 "-" + getEnvironmentName());
658 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
661 void Triple::setEnvironmentName(StringRef Str) {
662 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
666 void Triple::setOSAndEnvironmentName(StringRef Str) {
667 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
670 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
672 case llvm::Triple::UnknownArch:
675 case llvm::Triple::msp430:
678 case llvm::Triple::amdil:
679 case llvm::Triple::arm:
680 case llvm::Triple::hexagon:
681 case llvm::Triple::le32:
682 case llvm::Triple::mips:
683 case llvm::Triple::mipsel:
684 case llvm::Triple::nvptx:
685 case llvm::Triple::ppc:
686 case llvm::Triple::r600:
687 case llvm::Triple::sparc:
688 case llvm::Triple::tce:
689 case llvm::Triple::thumb:
690 case llvm::Triple::x86:
691 case llvm::Triple::xcore:
692 case llvm::Triple::spir:
695 case llvm::Triple::aarch64:
696 case llvm::Triple::mips64:
697 case llvm::Triple::mips64el:
698 case llvm::Triple::nvptx64:
699 case llvm::Triple::ppc64:
700 case llvm::Triple::ppc64le:
701 case llvm::Triple::sparcv9:
702 case llvm::Triple::systemz:
703 case llvm::Triple::x86_64:
704 case llvm::Triple::spir64:
707 llvm_unreachable("Invalid architecture value");
710 bool Triple::isArch64Bit() const {
711 return getArchPointerBitWidth(getArch()) == 64;
714 bool Triple::isArch32Bit() const {
715 return getArchPointerBitWidth(getArch()) == 32;
718 bool Triple::isArch16Bit() const {
719 return getArchPointerBitWidth(getArch()) == 16;
722 Triple Triple::get32BitArchVariant() const {
725 case Triple::UnknownArch:
726 case Triple::aarch64:
728 case Triple::systemz:
729 case Triple::ppc64le:
730 T.setArch(UnknownArch);
736 case Triple::hexagon:
751 case Triple::mips64: T.setArch(Triple::mips); break;
752 case Triple::mips64el: T.setArch(Triple::mipsel); break;
753 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
754 case Triple::ppc64: T.setArch(Triple::ppc); break;
755 case Triple::sparcv9: T.setArch(Triple::sparc); break;
756 case Triple::x86_64: T.setArch(Triple::x86); break;
757 case Triple::spir64: T.setArch(Triple::spir); break;
762 Triple Triple::get64BitArchVariant() const {
765 case Triple::UnknownArch:
768 case Triple::hexagon:
775 T.setArch(UnknownArch);
778 case Triple::aarch64:
781 case Triple::mips64el:
782 case Triple::nvptx64:
784 case Triple::ppc64le:
785 case Triple::sparcv9:
786 case Triple::systemz:
791 case Triple::mips: T.setArch(Triple::mips64); break;
792 case Triple::mipsel: T.setArch(Triple::mips64el); break;
793 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
794 case Triple::ppc: T.setArch(Triple::ppc64); break;
795 case Triple::sparc: T.setArch(Triple::sparcv9); break;
796 case Triple::x86: T.setArch(Triple::x86_64); break;
797 case Triple::spir: T.setArch(Triple::spir64); break;