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 arm: return "arm";
23 case hexagon: return "hexagon";
24 case mips: return "mips";
25 case mipsel: return "mipsel";
26 case mips64: return "mips64";
27 case mips64el:return "mips64el";
28 case msp430: return "msp430";
29 case ppc64: return "powerpc64";
30 case ppc: return "powerpc";
31 case r600: return "r600";
32 case sparc: return "sparc";
33 case sparcv9: return "sparcv9";
34 case tce: return "tce";
35 case thumb: return "thumb";
36 case x86: return "i386";
37 case x86_64: return "x86_64";
38 case xcore: return "xcore";
39 case mblaze: return "mblaze";
40 case nvptx: return "nvptx";
41 case nvptx64: return "nvptx64";
42 case le32: return "le32";
43 case amdil: return "amdil";
44 case spir: return "spir";
45 case spir64: return "spir64";
48 llvm_unreachable("Invalid ArchType!");
51 const char *Triple::getArchTypePrefix(ArchType Kind) {
57 case thumb: return "arm";
60 case ppc: return "ppc";
62 case mblaze: return "mblaze";
67 case mips64el:return "mips";
69 case hexagon: return "hexagon";
71 case r600: return "r600";
74 case sparc: return "sparc";
77 case x86_64: return "x86";
79 case xcore: return "xcore";
81 case nvptx: return "nvptx";
82 case nvptx64: return "nvptx";
83 case le32: return "le32";
84 case amdil: return "amdil";
85 case spir: return "spir";
86 case spir64: return "spir";
90 const char *Triple::getVendorTypeName(VendorType Kind) {
92 case UnknownVendor: return "unknown";
94 case Apple: return "apple";
96 case SCEI: return "scei";
97 case BGP: return "bgp";
98 case BGQ: return "bgq";
99 case Freescale: return "fsl";
100 case IBM: return "ibm";
103 llvm_unreachable("Invalid VendorType!");
106 const char *Triple::getOSTypeName(OSType Kind) {
108 case UnknownOS: return "unknown";
110 case AuroraUX: return "auroraux";
111 case Cygwin: return "cygwin";
112 case Darwin: return "darwin";
113 case DragonFly: return "dragonfly";
114 case FreeBSD: return "freebsd";
115 case IOS: return "ios";
116 case KFreeBSD: return "kfreebsd";
117 case Linux: return "linux";
118 case Lv2: return "lv2";
119 case MacOSX: return "macosx";
120 case MinGW32: return "mingw32";
121 case NetBSD: return "netbsd";
122 case OpenBSD: return "openbsd";
123 case Solaris: return "solaris";
124 case Win32: return "win32";
125 case Haiku: return "haiku";
126 case Minix: return "minix";
127 case RTEMS: return "rtems";
128 case NaCl: return "nacl";
129 case CNK: return "cnk";
130 case Bitrig: return "bitrig";
131 case AIX: return "aix";
134 llvm_unreachable("Invalid OSType");
137 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
139 case UnknownEnvironment: return "unknown";
140 case GNU: return "gnu";
141 case GNUEABIHF: return "gnueabihf";
142 case GNUEABI: return "gnueabi";
143 case EABI: return "eabi";
144 case MachO: return "macho";
145 case Android: return "android";
146 case ELF: return "elf";
149 llvm_unreachable("Invalid EnvironmentType!");
152 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
153 return StringSwitch<Triple::ArchType>(Name)
156 .Case("mipsel", mipsel)
157 .Case("mips64", mips64)
158 .Case("mips64el", mips64el)
159 .Case("msp430", msp430)
160 .Case("ppc64", ppc64)
163 .Case("mblaze", mblaze)
165 .Case("hexagon", hexagon)
166 .Case("sparc", sparc)
167 .Case("sparcv9", sparcv9)
169 .Case("thumb", thumb)
171 .Case("x86-64", x86_64)
172 .Case("xcore", xcore)
173 .Case("nvptx", nvptx)
174 .Case("nvptx64", nvptx64)
176 .Case("amdil", amdil)
178 .Case("spir64", spir64)
179 .Default(UnknownArch);
182 // Returns architecture name that is understood by the target assembler.
183 const char *Triple::getArchNameForAssembler() {
184 if (!isOSDarwin() && getVendor() != Triple::Apple)
187 return StringSwitch<const char*>(getArchName())
188 .Case("i386", "i386")
189 .Case("x86_64", "x86_64")
190 .Case("powerpc", "ppc")
191 .Case("powerpc64", "ppc64")
192 .Cases("mblaze", "microblaze", "mblaze")
194 .Cases("armv4t", "thumbv4t", "armv4t")
195 .Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5")
196 .Cases("armv6", "thumbv6", "armv6")
197 .Cases("armv7", "thumbv7", "armv7")
198 .Case("r600", "r600")
199 .Case("nvptx", "nvptx")
200 .Case("nvptx64", "nvptx64")
201 .Case("le32", "le32")
202 .Case("amdil", "amdil")
203 .Case("spir", "spir")
204 .Case("spir64", "spir64")
208 static Triple::ArchType parseArch(StringRef ArchName) {
209 return StringSwitch<Triple::ArchType>(ArchName)
210 .Cases("i386", "i486", "i586", "i686", Triple::x86)
211 // FIXME: Do we need to support these?
212 .Cases("i786", "i886", "i986", Triple::x86)
213 .Cases("amd64", "x86_64", Triple::x86_64)
214 .Case("powerpc", Triple::ppc)
215 .Cases("powerpc64", "ppu", Triple::ppc64)
216 .Case("mblaze", Triple::mblaze)
217 .Cases("arm", "xscale", Triple::arm)
218 // FIXME: It would be good to replace these with explicit names for all the
219 // various suffixes supported.
220 .StartsWith("armv", Triple::arm)
221 .Case("thumb", Triple::thumb)
222 .StartsWith("thumbv", Triple::thumb)
223 .Case("msp430", Triple::msp430)
224 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
225 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
226 .Cases("mips64", "mips64eb", Triple::mips64)
227 .Case("mips64el", Triple::mips64el)
228 .Case("r600", Triple::r600)
229 .Case("hexagon", Triple::hexagon)
230 .Case("sparc", Triple::sparc)
231 .Case("sparcv9", Triple::sparcv9)
232 .Case("tce", Triple::tce)
233 .Case("xcore", Triple::xcore)
234 .Case("nvptx", Triple::nvptx)
235 .Case("nvptx64", Triple::nvptx64)
236 .Case("le32", Triple::le32)
237 .Case("amdil", Triple::amdil)
238 .Case("spir", Triple::spir)
239 .Case("spir64", Triple::spir64)
240 .Default(Triple::UnknownArch);
243 static Triple::VendorType parseVendor(StringRef VendorName) {
244 return StringSwitch<Triple::VendorType>(VendorName)
245 .Case("apple", Triple::Apple)
246 .Case("pc", Triple::PC)
247 .Case("scei", Triple::SCEI)
248 .Case("bgp", Triple::BGP)
249 .Case("bgq", Triple::BGQ)
250 .Case("fsl", Triple::Freescale)
251 .Case("ibm", Triple::IBM)
252 .Default(Triple::UnknownVendor);
255 static Triple::OSType parseOS(StringRef OSName) {
256 return StringSwitch<Triple::OSType>(OSName)
257 .StartsWith("auroraux", Triple::AuroraUX)
258 .StartsWith("cygwin", Triple::Cygwin)
259 .StartsWith("darwin", Triple::Darwin)
260 .StartsWith("dragonfly", Triple::DragonFly)
261 .StartsWith("freebsd", Triple::FreeBSD)
262 .StartsWith("ios", Triple::IOS)
263 .StartsWith("kfreebsd", Triple::KFreeBSD)
264 .StartsWith("linux", Triple::Linux)
265 .StartsWith("lv2", Triple::Lv2)
266 .StartsWith("macosx", Triple::MacOSX)
267 .StartsWith("mingw32", Triple::MinGW32)
268 .StartsWith("netbsd", Triple::NetBSD)
269 .StartsWith("openbsd", Triple::OpenBSD)
270 .StartsWith("solaris", Triple::Solaris)
271 .StartsWith("win32", Triple::Win32)
272 .StartsWith("haiku", Triple::Haiku)
273 .StartsWith("minix", Triple::Minix)
274 .StartsWith("rtems", Triple::RTEMS)
275 .StartsWith("nacl", Triple::NaCl)
276 .StartsWith("cnk", Triple::CNK)
277 .StartsWith("bitrig", Triple::Bitrig)
278 .StartsWith("aix", Triple::AIX)
279 .Default(Triple::UnknownOS);
282 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
283 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
284 .StartsWith("eabi", Triple::EABI)
285 .StartsWith("gnueabihf", Triple::GNUEABIHF)
286 .StartsWith("gnueabi", Triple::GNUEABI)
287 .StartsWith("gnu", Triple::GNU)
288 .StartsWith("macho", Triple::MachO)
289 .StartsWith("android", Triple::Android)
290 .StartsWith("elf", Triple::ELF)
291 .Default(Triple::UnknownEnvironment);
294 /// \brief Construct a triple from the string representation provided.
296 /// This stores the string representation and parses the various pieces into
298 Triple::Triple(const Twine &Str)
300 Arch(parseArch(getArchName())),
301 Vendor(parseVendor(getVendorName())),
302 OS(parseOS(getOSName())),
303 Environment(parseEnvironment(getEnvironmentName())) {
306 /// \brief Construct a triple from string representations of the architecture,
309 /// This joins each argument into a canonical string representation and parses
310 /// them into enum members. It leaves the environment unknown and omits it from
311 /// the string representation.
312 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
313 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
314 Arch(parseArch(ArchStr.str())),
315 Vendor(parseVendor(VendorStr.str())),
316 OS(parseOS(OSStr.str())),
320 /// \brief Construct a triple from string representations of the architecture,
321 /// vendor, OS, and environment.
323 /// This joins each argument into a canonical string representation and parses
324 /// them into enum members.
325 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
326 const Twine &EnvironmentStr)
327 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
328 EnvironmentStr).str()),
329 Arch(parseArch(ArchStr.str())),
330 Vendor(parseVendor(VendorStr.str())),
331 OS(parseOS(OSStr.str())),
332 Environment(parseEnvironment(EnvironmentStr.str())) {
335 std::string Triple::normalize(StringRef Str) {
336 // Parse into components.
337 SmallVector<StringRef, 4> Components;
338 Str.split(Components, "-");
340 // If the first component corresponds to a known architecture, preferentially
341 // use it for the architecture. If the second component corresponds to a
342 // known vendor, preferentially use it for the vendor, etc. This avoids silly
343 // component movement when a component parses as (eg) both a valid arch and a
345 ArchType Arch = UnknownArch;
346 if (Components.size() > 0)
347 Arch = parseArch(Components[0]);
348 VendorType Vendor = UnknownVendor;
349 if (Components.size() > 1)
350 Vendor = parseVendor(Components[1]);
351 OSType OS = UnknownOS;
352 if (Components.size() > 2)
353 OS = parseOS(Components[2]);
354 EnvironmentType Environment = UnknownEnvironment;
355 if (Components.size() > 3)
356 Environment = parseEnvironment(Components[3]);
358 // Note which components are already in their final position. These will not
361 Found[0] = Arch != UnknownArch;
362 Found[1] = Vendor != UnknownVendor;
363 Found[2] = OS != UnknownOS;
364 Found[3] = Environment != UnknownEnvironment;
366 // If they are not there already, permute the components into their canonical
367 // positions by seeing if they parse as a valid architecture, and if so moving
368 // the component to the architecture position etc.
369 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
371 continue; // Already in the canonical position.
373 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
374 // Do not reparse any components that already matched.
375 if (Idx < array_lengthof(Found) && Found[Idx])
378 // Does this component parse as valid for the target position?
380 StringRef Comp = Components[Idx];
382 default: llvm_unreachable("unexpected component type!");
384 Arch = parseArch(Comp);
385 Valid = Arch != UnknownArch;
388 Vendor = parseVendor(Comp);
389 Valid = Vendor != UnknownVendor;
393 Valid = OS != UnknownOS;
396 Environment = parseEnvironment(Comp);
397 Valid = Environment != UnknownEnvironment;
401 continue; // Nope, try the next component.
403 // Move the component to the target position, pushing any non-fixed
404 // components that are in the way to the right. This tends to give
405 // good results in the common cases of a forgotten vendor component
406 // or a wrongly positioned environment.
408 // Insert left, pushing the existing components to the right. For
409 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
410 StringRef CurrentComponent(""); // The empty component.
411 // Replace the component we are moving with an empty component.
412 std::swap(CurrentComponent, Components[Idx]);
413 // Insert the component being moved at Pos, displacing any existing
414 // components to the right.
415 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
416 // Skip over any fixed components.
417 while (i < array_lengthof(Found) && Found[i])
419 // Place the component at the new position, getting the component
420 // that was at this position - it will be moved right.
421 std::swap(CurrentComponent, Components[i]);
423 } else if (Pos > Idx) {
424 // Push right by inserting empty components until the component at Idx
425 // reaches the target position Pos. For example, pc-a -> -pc-a when
426 // moving pc to the second position.
428 // Insert one empty component at Idx.
429 StringRef CurrentComponent(""); // The empty component.
430 for (unsigned i = Idx; i < Components.size();) {
431 // Place the component at the new position, getting the component
432 // that was at this position - it will be moved right.
433 std::swap(CurrentComponent, Components[i]);
434 // If it was placed on top of an empty component then we are done.
435 if (CurrentComponent.empty())
437 // Advance to the next component, skipping any fixed components.
438 while (++i < array_lengthof(Found) && Found[i])
441 // The last component was pushed off the end - append it.
442 if (!CurrentComponent.empty())
443 Components.push_back(CurrentComponent);
445 // Advance Idx to the component's new position.
446 while (++Idx < array_lengthof(Found) && Found[Idx])
448 } while (Idx < Pos); // Add more until the final position is reached.
450 assert(Pos < Components.size() && Components[Pos] == Comp &&
451 "Component moved wrong!");
457 // Special case logic goes here. At this point Arch, Vendor and OS have the
458 // correct values for the computed components.
460 // Stick the corrected components back together to form the normalized string.
461 std::string Normalized;
462 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
463 if (i) Normalized += '-';
464 Normalized += Components[i];
469 StringRef Triple::getArchName() const {
470 return StringRef(Data).split('-').first; // Isolate first component
473 StringRef Triple::getVendorName() const {
474 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
475 return Tmp.split('-').first; // Isolate second component
478 StringRef Triple::getOSName() const {
479 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
480 Tmp = Tmp.split('-').second; // Strip second component
481 return Tmp.split('-').first; // Isolate third component
484 StringRef Triple::getEnvironmentName() const {
485 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
486 Tmp = Tmp.split('-').second; // Strip second component
487 return Tmp.split('-').second; // Strip third component
490 StringRef Triple::getOSAndEnvironmentName() const {
491 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
492 return Tmp.split('-').second; // Strip second component
495 static unsigned EatNumber(StringRef &Str) {
496 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
500 // Consume the leading digit.
501 Result = Result*10 + (Str[0] - '0');
505 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
510 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
511 unsigned &Micro) const {
512 StringRef OSName = getOSName();
514 // Assume that the OS portion of the triple starts with the canonical name.
515 StringRef OSTypeName = getOSTypeName(getOS());
516 if (OSName.startswith(OSTypeName))
517 OSName = OSName.substr(OSTypeName.size());
519 // Any unset version defaults to 0.
520 Major = Minor = Micro = 0;
522 // Parse up to three components.
523 unsigned *Components[3] = { &Major, &Minor, &Micro };
524 for (unsigned i = 0; i != 3; ++i) {
525 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
528 // Consume the leading number.
529 *Components[i] = EatNumber(OSName);
531 // Consume the separator, if present.
532 if (OSName.startswith("."))
533 OSName = OSName.substr(1);
537 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
538 unsigned &Micro) const {
539 getOSVersion(Major, Minor, Micro);
542 default: llvm_unreachable("unexpected OS for Darwin triple");
544 // Default to darwin8, i.e., MacOSX 10.4.
547 // Darwin version numbers are skewed from OS X versions.
564 // Ignore the version from the triple. This is only handled because the
565 // the clang driver combines OS X and IOS support into a common Darwin
566 // toolchain that wants to know the OS X version number even when targeting
576 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
577 unsigned &Micro) const {
579 default: llvm_unreachable("unexpected OS for Darwin triple");
582 // Ignore the version from the triple. This is only handled because the
583 // the clang driver combines OS X and IOS support into a common Darwin
584 // toolchain that wants to know the iOS version number even when targeting
591 getOSVersion(Major, Minor, Micro);
599 void Triple::setTriple(const Twine &Str) {
603 void Triple::setArch(ArchType Kind) {
604 setArchName(getArchTypeName(Kind));
607 void Triple::setVendor(VendorType Kind) {
608 setVendorName(getVendorTypeName(Kind));
611 void Triple::setOS(OSType Kind) {
612 setOSName(getOSTypeName(Kind));
615 void Triple::setEnvironment(EnvironmentType Kind) {
616 setEnvironmentName(getEnvironmentTypeName(Kind));
619 void Triple::setArchName(StringRef Str) {
620 // Work around a miscompilation bug for Twines in gcc 4.0.3.
621 SmallString<64> Triple;
624 Triple += getVendorName();
626 Triple += getOSAndEnvironmentName();
627 setTriple(Triple.str());
630 void Triple::setVendorName(StringRef Str) {
631 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
634 void Triple::setOSName(StringRef Str) {
635 if (hasEnvironment())
636 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
637 "-" + getEnvironmentName());
639 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
642 void Triple::setEnvironmentName(StringRef Str) {
643 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
647 void Triple::setOSAndEnvironmentName(StringRef Str) {
648 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
651 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
653 case llvm::Triple::UnknownArch:
656 case llvm::Triple::msp430:
659 case llvm::Triple::amdil:
660 case llvm::Triple::arm:
661 case llvm::Triple::hexagon:
662 case llvm::Triple::le32:
663 case llvm::Triple::mblaze:
664 case llvm::Triple::mips:
665 case llvm::Triple::mipsel:
666 case llvm::Triple::nvptx:
667 case llvm::Triple::ppc:
668 case llvm::Triple::r600:
669 case llvm::Triple::sparc:
670 case llvm::Triple::tce:
671 case llvm::Triple::thumb:
672 case llvm::Triple::x86:
673 case llvm::Triple::xcore:
674 case llvm::Triple::spir:
677 case llvm::Triple::mips64:
678 case llvm::Triple::mips64el:
679 case llvm::Triple::nvptx64:
680 case llvm::Triple::ppc64:
681 case llvm::Triple::sparcv9:
682 case llvm::Triple::x86_64:
683 case llvm::Triple::spir64:
686 llvm_unreachable("Invalid architecture value");
689 bool Triple::isArch64Bit() const {
690 return getArchPointerBitWidth(getArch()) == 64;
693 bool Triple::isArch32Bit() const {
694 return getArchPointerBitWidth(getArch()) == 32;
697 bool Triple::isArch16Bit() const {
698 return getArchPointerBitWidth(getArch()) == 16;
701 Triple Triple::get32BitArchVariant() const {
704 case Triple::UnknownArch:
706 T.setArch(UnknownArch);
712 case Triple::hexagon:
728 case Triple::mips64: T.setArch(Triple::mips); break;
729 case Triple::mips64el: T.setArch(Triple::mipsel); break;
730 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
731 case Triple::ppc64: T.setArch(Triple::ppc); break;
732 case Triple::sparcv9: T.setArch(Triple::sparc); break;
733 case Triple::x86_64: T.setArch(Triple::x86); break;
734 case Triple::spir64: T.setArch(Triple::spir); break;
739 Triple Triple::get64BitArchVariant() const {
742 case Triple::UnknownArch:
745 case Triple::hexagon:
753 T.setArch(UnknownArch);
758 case Triple::mips64el:
759 case Triple::nvptx64:
761 case Triple::sparcv9:
766 case Triple::mips: T.setArch(Triple::mips64); break;
767 case Triple::mipsel: T.setArch(Triple::mips64el); break;
768 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
769 case Triple::ppc: T.setArch(Triple::ppc64); break;
770 case Triple::sparc: T.setArch(Triple::sparcv9); break;
771 case Triple::x86: T.setArch(Triple::x86_64); break;
772 case Triple::spir: T.setArch(Triple::spir64); break;