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/SmallString.h"
12 #include "llvm/ADT/StringSwitch.h"
13 #include "llvm/ADT/STLExtras.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 cellspu: return "cellspu";
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 ppc: return "powerpc";
32 case r600: return "r600";
33 case sparc: return "sparc";
34 case sparcv9: return "sparcv9";
35 case tce: return "tce";
36 case thumb: return "thumb";
37 case x86: return "i386";
38 case x86_64: return "x86_64";
39 case xcore: return "xcore";
40 case mblaze: return "mblaze";
41 case nvptx: return "nvptx";
42 case nvptx64: return "nvptx64";
43 case le32: return "le32";
44 case amdil: return "amdil";
45 case spir: return "spir";
48 llvm_unreachable("Invalid ArchType!");
51 const char *Triple::getArchTypePrefix(ArchType Kind) {
57 case thumb: return "arm";
59 case cellspu: return "spu";
62 case ppc: return "ppc";
64 case mblaze: return "mblaze";
69 case mips64el:return "mips";
71 case hexagon: return "hexagon";
73 case r600: return "r600";
76 case sparc: return "sparc";
79 case x86_64: return "x86";
81 case xcore: return "xcore";
83 case nvptx: return "nvptx";
84 case nvptx64: return "nvptx";
85 case le32: return "le32";
86 case amdil: return "amdil";
87 case spir: return "spir";
91 const char *Triple::getVendorTypeName(VendorType Kind) {
93 case UnknownVendor: return "unknown";
95 case Apple: return "apple";
97 case SCEI: return "scei";
98 case BGP: return "bgp";
99 case BGQ: return "bgq";
100 case Freescale: return "fsl";
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 NativeClient: return "nacl";
129 case CNK: return "cnk";
130 case Bitrig: return "bitrig";
133 llvm_unreachable("Invalid OSType");
136 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
138 case UnknownEnvironment: return "unknown";
139 case GNU: return "gnu";
140 case GNUEABIHF: return "gnueabihf";
141 case GNUEABI: return "gnueabi";
142 case EABI: return "eabi";
143 case MachO: return "macho";
144 case Android: return "android";
147 llvm_unreachable("Invalid EnvironmentType!");
150 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
151 return StringSwitch<Triple::ArchType>(Name)
153 .Case("cellspu", cellspu)
155 .Case("mipsel", mipsel)
156 .Case("mips64", mips64)
157 .Case("mips64el", mips64el)
158 .Case("msp430", msp430)
159 .Case("ppc64", ppc64)
162 .Case("mblaze", mblaze)
164 .Case("hexagon", hexagon)
165 .Case("sparc", sparc)
166 .Case("sparcv9", sparcv9)
168 .Case("thumb", thumb)
170 .Case("x86-64", x86_64)
171 .Case("xcore", xcore)
172 .Case("nvptx", nvptx)
173 .Case("nvptx64", nvptx64)
175 .Case("amdil", amdil)
177 .Default(UnknownArch);
180 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
181 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
182 // archs which Darwin doesn't use.
184 // The matching this routine does is fairly pointless, since it is neither the
185 // complete architecture list, nor a reasonable subset. The problem is that
186 // historically the driver driver accepts this and also ties its -march=
187 // handling to the architecture name, so we need to be careful before removing
190 // This code must be kept in sync with Clang's Darwin specific argument
193 return StringSwitch<ArchType>(Str)
194 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", Triple::ppc)
195 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", Triple::ppc)
196 .Case("ppc64", Triple::ppc64)
197 .Cases("i386", "i486", "i486SX", "i586", "i686", Triple::x86)
198 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
200 .Case("x86_64", Triple::x86_64)
201 // This is derived from the driver driver.
202 .Cases("arm", "armv4t", "armv5", "armv6", Triple::arm)
203 .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", Triple::arm)
204 .Case("r600", Triple::r600)
205 .Case("nvptx", Triple::nvptx)
206 .Case("nvptx64", Triple::nvptx64)
207 .Case("amdil", Triple::amdil)
208 .Case("spir", Triple::spir)
209 .Default(Triple::UnknownArch);
212 // Returns architecture name that is understood by the target assembler.
213 const char *Triple::getArchNameForAssembler() {
214 if (!isOSDarwin() && getVendor() != Triple::Apple)
217 return StringSwitch<const char*>(getArchName())
218 .Case("i386", "i386")
219 .Case("x86_64", "x86_64")
220 .Case("powerpc", "ppc")
221 .Case("powerpc64", "ppc64")
222 .Cases("mblaze", "microblaze", "mblaze")
224 .Cases("armv4t", "thumbv4t", "armv4t")
225 .Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5")
226 .Cases("armv6", "thumbv6", "armv6")
227 .Cases("armv7", "thumbv7", "armv7")
228 .Case("r600", "r600")
229 .Case("nvptx", "nvptx")
230 .Case("nvptx64", "nvptx64")
231 .Case("le32", "le32")
232 .Case("amdil", "amdil")
233 .Case("spir", "spir")
237 static Triple::ArchType parseArch(StringRef ArchName) {
238 return StringSwitch<Triple::ArchType>(ArchName)
239 .Cases("i386", "i486", "i586", "i686", Triple::x86)
240 // FIXME: Do we need to support these?
241 .Cases("i786", "i886", "i986", Triple::x86)
242 .Cases("amd64", "x86_64", Triple::x86_64)
243 .Case("powerpc", Triple::ppc)
244 .Cases("powerpc64", "ppu", Triple::ppc64)
245 .Case("mblaze", Triple::mblaze)
246 .Cases("arm", "xscale", Triple::arm)
247 // FIXME: It would be good to replace these with explicit names for all the
248 // various suffixes supported.
249 .StartsWith("armv", Triple::arm)
250 .Case("thumb", Triple::thumb)
251 .StartsWith("thumbv", Triple::thumb)
252 .Cases("spu", "cellspu", Triple::cellspu)
253 .Case("msp430", Triple::msp430)
254 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
255 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
256 .Cases("mips64", "mips64eb", Triple::mips64)
257 .Case("mips64el", Triple::mips64el)
258 .Case("r600", Triple::r600)
259 .Case("hexagon", Triple::hexagon)
260 .Case("sparc", Triple::sparc)
261 .Case("sparcv9", Triple::sparcv9)
262 .Case("tce", Triple::tce)
263 .Case("xcore", Triple::xcore)
264 .Case("nvptx", Triple::nvptx)
265 .Case("nvptx64", Triple::nvptx64)
266 .Case("le32", Triple::le32)
267 .Case("amdil", Triple::amdil)
268 .Case("spir", Triple::spir)
269 .Default(Triple::UnknownArch);
272 static Triple::VendorType parseVendor(StringRef VendorName) {
273 return StringSwitch<Triple::VendorType>(VendorName)
274 .Case("apple", Triple::Apple)
275 .Case("pc", Triple::PC)
276 .Case("scei", Triple::SCEI)
277 .Case("bgp", Triple::BGP)
278 .Case("bgq", Triple::BGQ)
279 .Case("fsl", Triple::Freescale)
280 .Default(Triple::UnknownVendor);
283 static Triple::OSType parseOS(StringRef OSName) {
284 return StringSwitch<Triple::OSType>(OSName)
285 .StartsWith("auroraux", Triple::AuroraUX)
286 .StartsWith("cygwin", Triple::Cygwin)
287 .StartsWith("darwin", Triple::Darwin)
288 .StartsWith("dragonfly", Triple::DragonFly)
289 .StartsWith("freebsd", Triple::FreeBSD)
290 .StartsWith("ios", Triple::IOS)
291 .StartsWith("kfreebsd", Triple::KFreeBSD)
292 .StartsWith("linux", Triple::Linux)
293 .StartsWith("lv2", Triple::Lv2)
294 .StartsWith("macosx", Triple::MacOSX)
295 .StartsWith("mingw32", Triple::MinGW32)
296 .StartsWith("netbsd", Triple::NetBSD)
297 .StartsWith("openbsd", Triple::OpenBSD)
298 .StartsWith("solaris", Triple::Solaris)
299 .StartsWith("win32", Triple::Win32)
300 .StartsWith("haiku", Triple::Haiku)
301 .StartsWith("minix", Triple::Minix)
302 .StartsWith("rtems", Triple::RTEMS)
303 .StartsWith("nacl", Triple::NativeClient)
304 .StartsWith("cnk", Triple::CNK)
305 .StartsWith("bitrig", Triple::Bitrig)
306 .Default(Triple::UnknownOS);
309 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
310 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
311 .StartsWith("eabi", Triple::EABI)
312 .StartsWith("gnueabihf", Triple::GNUEABIHF)
313 .StartsWith("gnueabi", Triple::GNUEABI)
314 .StartsWith("gnu", Triple::GNU)
315 .StartsWith("macho", Triple::MachO)
316 .StartsWith("android", Triple::Android)
317 .Default(Triple::UnknownEnvironment);
320 /// \brief Construct a triple from the string representation provided.
322 /// This stores the string representation and parses the various pieces into
324 Triple::Triple(const Twine &Str)
326 Arch(parseArch(getArchName())),
327 Vendor(parseVendor(getVendorName())),
328 OS(parseOS(getOSName())),
329 Environment(parseEnvironment(getEnvironmentName())) {
332 /// \brief Construct a triple from string representations of the architecture,
335 /// This joins each argument into a canonical string representation and parses
336 /// them into enum members. It leaves the environment unknown and omits it from
337 /// the string representation.
338 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
339 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
340 Arch(parseArch(ArchStr.str())),
341 Vendor(parseVendor(VendorStr.str())),
342 OS(parseOS(OSStr.str())),
346 /// \brief Construct a triple from string representations of the architecture,
347 /// vendor, OS, and environment.
349 /// This joins each argument into a canonical string representation and parses
350 /// them into enum members.
351 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
352 const Twine &EnvironmentStr)
353 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
354 EnvironmentStr).str()),
355 Arch(parseArch(ArchStr.str())),
356 Vendor(parseVendor(VendorStr.str())),
357 OS(parseOS(OSStr.str())),
358 Environment(parseEnvironment(EnvironmentStr.str())) {
361 std::string Triple::normalize(StringRef Str) {
362 // Parse into components.
363 SmallVector<StringRef, 4> Components;
364 Str.split(Components, "-");
366 // If the first component corresponds to a known architecture, preferentially
367 // use it for the architecture. If the second component corresponds to a
368 // known vendor, preferentially use it for the vendor, etc. This avoids silly
369 // component movement when a component parses as (eg) both a valid arch and a
371 ArchType Arch = UnknownArch;
372 if (Components.size() > 0)
373 Arch = parseArch(Components[0]);
374 VendorType Vendor = UnknownVendor;
375 if (Components.size() > 1)
376 Vendor = parseVendor(Components[1]);
377 OSType OS = UnknownOS;
378 if (Components.size() > 2)
379 OS = parseOS(Components[2]);
380 EnvironmentType Environment = UnknownEnvironment;
381 if (Components.size() > 3)
382 Environment = parseEnvironment(Components[3]);
384 // Note which components are already in their final position. These will not
387 Found[0] = Arch != UnknownArch;
388 Found[1] = Vendor != UnknownVendor;
389 Found[2] = OS != UnknownOS;
390 Found[3] = Environment != UnknownEnvironment;
392 // If they are not there already, permute the components into their canonical
393 // positions by seeing if they parse as a valid architecture, and if so moving
394 // the component to the architecture position etc.
395 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
397 continue; // Already in the canonical position.
399 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
400 // Do not reparse any components that already matched.
401 if (Idx < array_lengthof(Found) && Found[Idx])
404 // Does this component parse as valid for the target position?
406 StringRef Comp = Components[Idx];
408 default: llvm_unreachable("unexpected component type!");
410 Arch = parseArch(Comp);
411 Valid = Arch != UnknownArch;
414 Vendor = parseVendor(Comp);
415 Valid = Vendor != UnknownVendor;
419 Valid = OS != UnknownOS;
422 Environment = parseEnvironment(Comp);
423 Valid = Environment != UnknownEnvironment;
427 continue; // Nope, try the next component.
429 // Move the component to the target position, pushing any non-fixed
430 // components that are in the way to the right. This tends to give
431 // good results in the common cases of a forgotten vendor component
432 // or a wrongly positioned environment.
434 // Insert left, pushing the existing components to the right. For
435 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
436 StringRef CurrentComponent(""); // The empty component.
437 // Replace the component we are moving with an empty component.
438 std::swap(CurrentComponent, Components[Idx]);
439 // Insert the component being moved at Pos, displacing any existing
440 // components to the right.
441 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
442 // Skip over any fixed components.
443 while (i < array_lengthof(Found) && Found[i])
445 // Place the component at the new position, getting the component
446 // that was at this position - it will be moved right.
447 std::swap(CurrentComponent, Components[i]);
449 } else if (Pos > Idx) {
450 // Push right by inserting empty components until the component at Idx
451 // reaches the target position Pos. For example, pc-a -> -pc-a when
452 // moving pc to the second position.
454 // Insert one empty component at Idx.
455 StringRef CurrentComponent(""); // The empty component.
456 for (unsigned i = Idx; i < Components.size();) {
457 // Place the component at the new position, getting the component
458 // that was at this position - it will be moved right.
459 std::swap(CurrentComponent, Components[i]);
460 // If it was placed on top of an empty component then we are done.
461 if (CurrentComponent.empty())
463 // Advance to the next component, skipping any fixed components.
464 while (++i < array_lengthof(Found) && Found[i])
467 // The last component was pushed off the end - append it.
468 if (!CurrentComponent.empty())
469 Components.push_back(CurrentComponent);
471 // Advance Idx to the component's new position.
472 while (++Idx < array_lengthof(Found) && Found[Idx])
474 } while (Idx < Pos); // Add more until the final position is reached.
476 assert(Pos < Components.size() && Components[Pos] == Comp &&
477 "Component moved wrong!");
483 // Special case logic goes here. At this point Arch, Vendor and OS have the
484 // correct values for the computed components.
486 // Stick the corrected components back together to form the normalized string.
487 std::string Normalized;
488 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
489 if (i) Normalized += '-';
490 Normalized += Components[i];
495 StringRef Triple::getArchName() const {
496 return StringRef(Data).split('-').first; // Isolate first component
499 StringRef Triple::getVendorName() const {
500 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
501 return Tmp.split('-').first; // Isolate second component
504 StringRef Triple::getOSName() const {
505 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
506 Tmp = Tmp.split('-').second; // Strip second component
507 return Tmp.split('-').first; // Isolate third component
510 StringRef Triple::getEnvironmentName() const {
511 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
512 Tmp = Tmp.split('-').second; // Strip second component
513 return Tmp.split('-').second; // Strip third component
516 StringRef Triple::getOSAndEnvironmentName() const {
517 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
518 return Tmp.split('-').second; // Strip second component
521 static unsigned EatNumber(StringRef &Str) {
522 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
526 // Consume the leading digit.
527 Result = Result*10 + (Str[0] - '0');
531 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
536 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
537 unsigned &Micro) const {
538 StringRef OSName = getOSName();
540 // Assume that the OS portion of the triple starts with the canonical name.
541 StringRef OSTypeName = getOSTypeName(getOS());
542 if (OSName.startswith(OSTypeName))
543 OSName = OSName.substr(OSTypeName.size());
545 // Any unset version defaults to 0.
546 Major = Minor = Micro = 0;
548 // Parse up to three components.
549 unsigned *Components[3] = { &Major, &Minor, &Micro };
550 for (unsigned i = 0; i != 3; ++i) {
551 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
554 // Consume the leading number.
555 *Components[i] = EatNumber(OSName);
557 // Consume the separator, if present.
558 if (OSName.startswith("."))
559 OSName = OSName.substr(1);
563 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
564 unsigned &Micro) const {
565 getOSVersion(Major, Minor, Micro);
568 default: llvm_unreachable("unexpected OS for Darwin triple");
570 // Default to darwin8, i.e., MacOSX 10.4.
573 // Darwin version numbers are skewed from OS X versions.
590 // Ignore the version from the triple. This is only handled because the
591 // the clang driver combines OS X and IOS support into a common Darwin
592 // toolchain that wants to know the OS X version number even when targeting
602 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
603 unsigned &Micro) const {
605 default: llvm_unreachable("unexpected OS for Darwin triple");
608 // Ignore the version from the triple. This is only handled because the
609 // the clang driver combines OS X and IOS support into a common Darwin
610 // toolchain that wants to know the iOS version number even when targeting
617 getOSVersion(Major, Minor, Micro);
625 void Triple::setTriple(const Twine &Str) {
629 void Triple::setArch(ArchType Kind) {
630 setArchName(getArchTypeName(Kind));
633 void Triple::setVendor(VendorType Kind) {
634 setVendorName(getVendorTypeName(Kind));
637 void Triple::setOS(OSType Kind) {
638 setOSName(getOSTypeName(Kind));
641 void Triple::setEnvironment(EnvironmentType Kind) {
642 setEnvironmentName(getEnvironmentTypeName(Kind));
645 void Triple::setArchName(StringRef Str) {
646 // Work around a miscompilation bug for Twines in gcc 4.0.3.
647 SmallString<64> Triple;
650 Triple += getVendorName();
652 Triple += getOSAndEnvironmentName();
653 setTriple(Triple.str());
656 void Triple::setVendorName(StringRef Str) {
657 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
660 void Triple::setOSName(StringRef Str) {
661 if (hasEnvironment())
662 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
663 "-" + getEnvironmentName());
665 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
668 void Triple::setEnvironmentName(StringRef Str) {
669 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
673 void Triple::setOSAndEnvironmentName(StringRef Str) {
674 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
677 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
679 case llvm::Triple::spir:
680 case llvm::Triple::UnknownArch:
683 case llvm::Triple::msp430:
686 case llvm::Triple::amdil:
687 case llvm::Triple::arm:
688 case llvm::Triple::cellspu:
689 case llvm::Triple::hexagon:
690 case llvm::Triple::le32:
691 case llvm::Triple::mblaze:
692 case llvm::Triple::mips:
693 case llvm::Triple::mipsel:
694 case llvm::Triple::nvptx:
695 case llvm::Triple::ppc:
696 case llvm::Triple::r600:
697 case llvm::Triple::sparc:
698 case llvm::Triple::tce:
699 case llvm::Triple::thumb:
700 case llvm::Triple::x86:
701 case llvm::Triple::xcore:
704 case llvm::Triple::mips64:
705 case llvm::Triple::mips64el:
706 case llvm::Triple::nvptx64:
707 case llvm::Triple::ppc64:
708 case llvm::Triple::sparcv9:
709 case llvm::Triple::x86_64:
712 llvm_unreachable("Invalid architecture value");
715 bool Triple::isArch64Bit() const {
716 return getArchPointerBitWidth(getArch()) == 64;
719 bool Triple::isArch32Bit() const {
720 return getArchPointerBitWidth(getArch()) == 32;
723 bool Triple::isArch16Bit() const {
724 return getArchPointerBitWidth(getArch()) == 16;
727 Triple Triple::get32BitArchVariant() const {
730 case Triple::UnknownArch:
732 T.setArch(UnknownArch);
738 case Triple::cellspu:
739 case Triple::hexagon:
755 case Triple::mips64: T.setArch(Triple::mips); break;
756 case Triple::mips64el: T.setArch(Triple::mipsel); break;
757 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
758 case Triple::ppc64: T.setArch(Triple::ppc); break;
759 case Triple::sparcv9: T.setArch(Triple::sparc); break;
760 case Triple::x86_64: T.setArch(Triple::x86); break;
765 Triple Triple::get64BitArchVariant() const {
768 case Triple::UnknownArch:
771 case Triple::cellspu:
772 case Triple::hexagon:
780 T.setArch(UnknownArch);
785 case Triple::mips64el:
786 case Triple::nvptx64:
788 case Triple::sparcv9:
793 case Triple::mips: T.setArch(Triple::mips64); break;
794 case Triple::mipsel: T.setArch(Triple::mips64el); break;
795 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
796 case Triple::ppc: T.setArch(Triple::ppc64); break;
797 case Triple::sparc: T.setArch(Triple::sparcv9); break;
798 case Triple::x86: T.setArch(Triple::x86_64); break;