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 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 ptx32: return "ptx32";
41 case ptx64: return "ptx64";
42 case le32: return "le32";
43 case amdil: return "amdil";
46 llvm_unreachable("Invalid ArchType!");
49 const char *Triple::getArchTypePrefix(ArchType Kind) {
55 case thumb: return "arm";
57 case cellspu: return "spu";
60 case ppc: return "ppc";
62 case mblaze: return "mblaze";
64 case hexagon: return "hexagon";
67 case sparc: return "sparc";
70 case x86_64: return "x86";
72 case xcore: return "xcore";
74 case ptx32: return "ptx";
75 case ptx64: return "ptx";
76 case le32: return "le32";
77 case amdil: return "amdil";
81 const char *Triple::getVendorTypeName(VendorType Kind) {
83 case UnknownVendor: return "unknown";
85 case Apple: return "apple";
87 case SCEI: return "scei";
90 llvm_unreachable("Invalid VendorType!");
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 KFreeBSD: return "kfreebsd";
104 case Linux: return "linux";
105 case Lv2: return "lv2";
106 case MacOSX: return "macosx";
107 case MinGW32: return "mingw32";
108 case NetBSD: return "netbsd";
109 case OpenBSD: return "openbsd";
110 case Solaris: return "solaris";
111 case Win32: return "win32";
112 case Haiku: return "haiku";
113 case Minix: return "minix";
114 case RTEMS: return "rtems";
115 case NativeClient: return "nacl";
118 llvm_unreachable("Invalid OSType");
121 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
123 case UnknownEnvironment: return "unknown";
124 case GNU: return "gnu";
125 case GNUEABIHF: return "gnueabihf";
126 case GNUEABI: return "gnueabi";
127 case EABI: return "eabi";
128 case MachO: return "macho";
129 case ANDROIDEABI: return "androideabi";
132 llvm_unreachable("Invalid EnvironmentType!");
135 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
136 return StringSwitch<Triple::ArchType>(Name)
138 .Case("cellspu", cellspu)
140 .Case("mipsel", mipsel)
141 .Case("mips64", mips64)
142 .Case("mips64el", mips64el)
143 .Case("msp430", msp430)
144 .Case("ppc64", ppc64)
147 .Case("mblaze", mblaze)
148 .Case("hexagon", hexagon)
149 .Case("sparc", sparc)
150 .Case("sparcv9", sparcv9)
152 .Case("thumb", thumb)
154 .Case("x86-64", x86_64)
155 .Case("xcore", xcore)
156 .Case("ptx32", ptx32)
157 .Case("ptx64", ptx64)
159 .Case("amdil", amdil)
160 .Default(UnknownArch);
163 Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) {
164 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
165 // archs which Darwin doesn't use.
167 // The matching this routine does is fairly pointless, since it is neither the
168 // complete architecture list, nor a reasonable subset. The problem is that
169 // historically the driver driver accepts this and also ties its -march=
170 // handling to the architecture name, so we need to be careful before removing
173 // This code must be kept in sync with Clang's Darwin specific argument
176 return StringSwitch<ArchType>(Str)
177 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", Triple::ppc)
178 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", Triple::ppc)
179 .Case("ppc64", Triple::ppc64)
180 .Cases("i386", "i486", "i486SX", "i586", "i686", Triple::x86)
181 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
183 .Case("x86_64", Triple::x86_64)
184 // This is derived from the driver driver.
185 .Cases("arm", "armv4t", "armv5", "armv6", Triple::arm)
186 .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", Triple::arm)
187 .Case("ptx32", Triple::ptx32)
188 .Case("ptx64", Triple::ptx64)
189 .Case("amdil", Triple::amdil)
190 .Default(Triple::UnknownArch);
193 // Returns architecture name that is understood by the target assembler.
194 const char *Triple::getArchNameForAssembler() {
195 if (!isOSDarwin() && getVendor() != Triple::Apple)
198 return StringSwitch<const char*>(getArchName())
199 .Case("i386", "i386")
200 .Case("x86_64", "x86_64")
201 .Case("powerpc", "ppc")
202 .Case("powerpc64", "ppc64")
203 .Cases("mblaze", "microblaze", "mblaze")
205 .Cases("armv4t", "thumbv4t", "armv4t")
206 .Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5")
207 .Cases("armv6", "thumbv6", "armv6")
208 .Cases("armv7", "thumbv7", "armv7")
209 .Case("ptx32", "ptx32")
210 .Case("ptx64", "ptx64")
211 .Case("le32", "le32")
212 .Case("amdil", "amdil")
216 static Triple::ArchType parseArch(StringRef ArchName) {
217 return StringSwitch<Triple::ArchType>(ArchName)
218 .Cases("i386", "i486", "i586", "i686", Triple::x86)
219 // FIXME: Do we need to support these?
220 .Cases("i786", "i886", "i986", Triple::x86)
221 .Cases("amd64", "x86_64", Triple::x86_64)
222 .Case("powerpc", Triple::ppc)
223 .Cases("powerpc64", "ppu", Triple::ppc64)
224 .Case("mblaze", Triple::mblaze)
225 .Cases("arm", "xscale", Triple::arm)
226 // FIXME: It would be good to replace these with explicit names for all the
227 // various suffixes supported.
228 .StartsWith("armv", Triple::arm)
229 .Case("thumb", Triple::thumb)
230 .StartsWith("thumbv", Triple::thumb)
231 .Cases("spu", "cellspu", Triple::cellspu)
232 .Case("msp430", Triple::msp430)
233 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
234 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
235 .Cases("mips64", "mips64eb", Triple::mips64)
236 .Case("mips64el", Triple::mips64el)
237 .Case("hexagon", Triple::hexagon)
238 .Case("sparc", Triple::sparc)
239 .Case("sparcv9", Triple::sparcv9)
240 .Case("tce", Triple::tce)
241 .Case("xcore", Triple::xcore)
242 .Case("ptx32", Triple::ptx32)
243 .Case("ptx64", Triple::ptx64)
244 .Case("le32", Triple::le32)
245 .Case("amdil", Triple::amdil)
246 .Default(Triple::UnknownArch);
249 static Triple::VendorType parseVendor(StringRef VendorName) {
250 return StringSwitch<Triple::VendorType>(VendorName)
251 .Case("apple", Triple::Apple)
252 .Case("pc", Triple::PC)
253 .Case("scei", Triple::SCEI)
254 .Default(Triple::UnknownVendor);
257 static Triple::OSType parseOS(StringRef OSName) {
258 return StringSwitch<Triple::OSType>(OSName)
259 .StartsWith("auroraux", Triple::AuroraUX)
260 .StartsWith("cygwin", Triple::Cygwin)
261 .StartsWith("darwin", Triple::Darwin)
262 .StartsWith("dragonfly", Triple::DragonFly)
263 .StartsWith("freebsd", Triple::FreeBSD)
264 .StartsWith("ios", Triple::IOS)
265 .StartsWith("kfreebsd", Triple::KFreeBSD)
266 .StartsWith("linux", Triple::Linux)
267 .StartsWith("lv2", Triple::Lv2)
268 .StartsWith("macosx", Triple::MacOSX)
269 .StartsWith("mingw32", Triple::MinGW32)
270 .StartsWith("netbsd", Triple::NetBSD)
271 .StartsWith("openbsd", Triple::OpenBSD)
272 .StartsWith("solaris", Triple::Solaris)
273 .StartsWith("win32", Triple::Win32)
274 .StartsWith("haiku", Triple::Haiku)
275 .StartsWith("minix", Triple::Minix)
276 .StartsWith("rtems", Triple::RTEMS)
277 .StartsWith("nacl", Triple::NativeClient)
278 .Default(Triple::UnknownOS);
281 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
282 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
283 .StartsWith("eabi", Triple::EABI)
284 .StartsWith("gnueabihf", Triple::GNUEABIHF)
285 .StartsWith("gnueabi", Triple::GNUEABI)
286 .StartsWith("gnu", Triple::GNU)
287 .StartsWith("macho", Triple::MachO)
288 .StartsWith("androideabi", Triple::ANDROIDEABI)
289 .Default(Triple::UnknownEnvironment);
292 /// \brief Construct a triple from the string representation provided.
294 /// This stores the string representation and parses the various pieces into
296 Triple::Triple(const Twine &Str)
298 Arch(parseArch(getArchName())),
299 Vendor(parseVendor(getVendorName())),
300 OS(parseOS(getOSName())),
301 Environment(parseEnvironment(getEnvironmentName())) {
304 /// \brief Construct a triple from string representations of the architecture,
307 /// This joins each argument into a canonical string representation and parses
308 /// them into enum members. It leaves the environment unknown and omits it from
309 /// the string representation.
310 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
311 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
312 Arch(parseArch(ArchStr.str())),
313 Vendor(parseVendor(VendorStr.str())),
314 OS(parseOS(OSStr.str())),
318 /// \brief Construct a triple from string representations of the architecture,
319 /// vendor, OS, and environment.
321 /// This joins each argument into a canonical string representation and parses
322 /// them into enum members.
323 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
324 const Twine &EnvironmentStr)
325 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
326 EnvironmentStr).str()),
327 Arch(parseArch(ArchStr.str())),
328 Vendor(parseVendor(VendorStr.str())),
329 OS(parseOS(OSStr.str())),
330 Environment(parseEnvironment(EnvironmentStr.str())) {
333 std::string Triple::normalize(StringRef Str) {
334 // Parse into components.
335 SmallVector<StringRef, 4> Components;
336 Str.split(Components, "-");
338 // If the first component corresponds to a known architecture, preferentially
339 // use it for the architecture. If the second component corresponds to a
340 // known vendor, preferentially use it for the vendor, etc. This avoids silly
341 // component movement when a component parses as (eg) both a valid arch and a
343 ArchType Arch = UnknownArch;
344 if (Components.size() > 0)
345 Arch = parseArch(Components[0]);
346 VendorType Vendor = UnknownVendor;
347 if (Components.size() > 1)
348 Vendor = parseVendor(Components[1]);
349 OSType OS = UnknownOS;
350 if (Components.size() > 2)
351 OS = parseOS(Components[2]);
352 EnvironmentType Environment = UnknownEnvironment;
353 if (Components.size() > 3)
354 Environment = parseEnvironment(Components[3]);
356 // Note which components are already in their final position. These will not
359 Found[0] = Arch != UnknownArch;
360 Found[1] = Vendor != UnknownVendor;
361 Found[2] = OS != UnknownOS;
362 Found[3] = Environment != UnknownEnvironment;
364 // If they are not there already, permute the components into their canonical
365 // positions by seeing if they parse as a valid architecture, and if so moving
366 // the component to the architecture position etc.
367 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
369 continue; // Already in the canonical position.
371 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
372 // Do not reparse any components that already matched.
373 if (Idx < array_lengthof(Found) && Found[Idx])
376 // Does this component parse as valid for the target position?
378 StringRef Comp = Components[Idx];
380 default: llvm_unreachable("unexpected component type!");
382 Arch = parseArch(Comp);
383 Valid = Arch != UnknownArch;
386 Vendor = parseVendor(Comp);
387 Valid = Vendor != UnknownVendor;
391 Valid = OS != UnknownOS;
394 Environment = parseEnvironment(Comp);
395 Valid = Environment != UnknownEnvironment;
399 continue; // Nope, try the next component.
401 // Move the component to the target position, pushing any non-fixed
402 // components that are in the way to the right. This tends to give
403 // good results in the common cases of a forgotten vendor component
404 // or a wrongly positioned environment.
406 // Insert left, pushing the existing components to the right. For
407 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
408 StringRef CurrentComponent(""); // The empty component.
409 // Replace the component we are moving with an empty component.
410 std::swap(CurrentComponent, Components[Idx]);
411 // Insert the component being moved at Pos, displacing any existing
412 // components to the right.
413 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
414 // Skip over any fixed components.
415 while (i < array_lengthof(Found) && Found[i])
417 // Place the component at the new position, getting the component
418 // that was at this position - it will be moved right.
419 std::swap(CurrentComponent, Components[i]);
421 } else if (Pos > Idx) {
422 // Push right by inserting empty components until the component at Idx
423 // reaches the target position Pos. For example, pc-a -> -pc-a when
424 // moving pc to the second position.
426 // Insert one empty component at Idx.
427 StringRef CurrentComponent(""); // The empty component.
428 for (unsigned i = Idx; i < Components.size();) {
429 // Place the component at the new position, getting the component
430 // that was at this position - it will be moved right.
431 std::swap(CurrentComponent, Components[i]);
432 // If it was placed on top of an empty component then we are done.
433 if (CurrentComponent.empty())
435 // Advance to the next component, skipping any fixed components.
436 while (++i < array_lengthof(Found) && Found[i])
439 // The last component was pushed off the end - append it.
440 if (!CurrentComponent.empty())
441 Components.push_back(CurrentComponent);
443 // Advance Idx to the component's new position.
444 while (++Idx < array_lengthof(Found) && Found[Idx])
446 } while (Idx < Pos); // Add more until the final position is reached.
448 assert(Pos < Components.size() && Components[Pos] == Comp &&
449 "Component moved wrong!");
455 // Special case logic goes here. At this point Arch, Vendor and OS have the
456 // correct values for the computed components.
458 // Stick the corrected components back together to form the normalized string.
459 std::string Normalized;
460 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
461 if (i) Normalized += '-';
462 Normalized += Components[i];
467 StringRef Triple::getArchName() const {
468 return StringRef(Data).split('-').first; // Isolate first component
471 StringRef Triple::getVendorName() const {
472 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
473 return Tmp.split('-').first; // Isolate second component
476 StringRef Triple::getOSName() const {
477 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
478 Tmp = Tmp.split('-').second; // Strip second component
479 return Tmp.split('-').first; // Isolate third component
482 StringRef Triple::getEnvironmentName() const {
483 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
484 Tmp = Tmp.split('-').second; // Strip second component
485 return Tmp.split('-').second; // Strip third component
488 StringRef Triple::getOSAndEnvironmentName() const {
489 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
490 return Tmp.split('-').second; // Strip second component
493 static unsigned EatNumber(StringRef &Str) {
494 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
498 // Consume the leading digit.
499 Result = Result*10 + (Str[0] - '0');
503 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
508 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
509 unsigned &Micro) const {
510 StringRef OSName = getOSName();
512 // Assume that the OS portion of the triple starts with the canonical name.
513 StringRef OSTypeName = getOSTypeName(getOS());
514 if (OSName.startswith(OSTypeName))
515 OSName = OSName.substr(OSTypeName.size());
517 // Any unset version defaults to 0.
518 Major = Minor = Micro = 0;
520 // Parse up to three components.
521 unsigned *Components[3] = { &Major, &Minor, &Micro };
522 for (unsigned i = 0; i != 3; ++i) {
523 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
526 // Consume the leading number.
527 *Components[i] = EatNumber(OSName);
529 // Consume the separator, if present.
530 if (OSName.startswith("."))
531 OSName = OSName.substr(1);
535 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
536 unsigned &Micro) const {
537 getOSVersion(Major, Minor, Micro);
540 default: llvm_unreachable("unexpected OS for Darwin triple");
542 // Default to darwin8, i.e., MacOSX 10.4.
545 // Darwin version numbers are skewed from OS X versions.
562 // Ignore the version from the triple. This is only handled because the
563 // the clang driver combines OS X and IOS support into a common Darwin
564 // toolchain that wants to know the OS X version number even when targeting
574 void Triple::setTriple(const Twine &Str) {
578 void Triple::setArch(ArchType Kind) {
579 setArchName(getArchTypeName(Kind));
582 void Triple::setVendor(VendorType Kind) {
583 setVendorName(getVendorTypeName(Kind));
586 void Triple::setOS(OSType Kind) {
587 setOSName(getOSTypeName(Kind));
590 void Triple::setEnvironment(EnvironmentType Kind) {
591 setEnvironmentName(getEnvironmentTypeName(Kind));
594 void Triple::setArchName(StringRef Str) {
595 // Work around a miscompilation bug for Twines in gcc 4.0.3.
596 SmallString<64> Triple;
599 Triple += getVendorName();
601 Triple += getOSAndEnvironmentName();
602 setTriple(Triple.str());
605 void Triple::setVendorName(StringRef Str) {
606 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
609 void Triple::setOSName(StringRef Str) {
610 if (hasEnvironment())
611 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
612 "-" + getEnvironmentName());
614 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
617 void Triple::setEnvironmentName(StringRef Str) {
618 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
622 void Triple::setOSAndEnvironmentName(StringRef Str) {
623 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
626 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
628 case llvm::Triple::UnknownArch:
631 case llvm::Triple::msp430:
634 case llvm::Triple::amdil:
635 case llvm::Triple::arm:
636 case llvm::Triple::cellspu:
637 case llvm::Triple::hexagon:
638 case llvm::Triple::le32:
639 case llvm::Triple::mblaze:
640 case llvm::Triple::mips:
641 case llvm::Triple::mipsel:
642 case llvm::Triple::ppc:
643 case llvm::Triple::ptx32:
644 case llvm::Triple::sparc:
645 case llvm::Triple::tce:
646 case llvm::Triple::thumb:
647 case llvm::Triple::x86:
648 case llvm::Triple::xcore:
651 case llvm::Triple::mips64:
652 case llvm::Triple::mips64el:
653 case llvm::Triple::ppc64:
654 case llvm::Triple::ptx64:
655 case llvm::Triple::sparcv9:
656 case llvm::Triple::x86_64:
659 llvm_unreachable("Invalid architecture value");
662 bool Triple::isArch64Bit() const {
663 return getArchPointerBitWidth(getArch()) == 64;
666 bool Triple::isArch32Bit() const {
667 return getArchPointerBitWidth(getArch()) == 32;
670 bool Triple::isArch16Bit() const {
671 return getArchPointerBitWidth(getArch()) == 16;
674 Triple Triple::get32BitArchVariant() const {
677 case Triple::UnknownArch:
679 T.setArch(UnknownArch);
684 case Triple::cellspu:
685 case Triple::hexagon:
700 case Triple::mips64: T.setArch(Triple::mips); break;
701 case Triple::mips64el: T.setArch(Triple::mipsel); break;
702 case Triple::ppc64: T.setArch(Triple::ppc); break;
703 case Triple::ptx64: T.setArch(Triple::ptx32); break;
704 case Triple::sparcv9: T.setArch(Triple::sparc); break;
705 case Triple::x86_64: T.setArch(Triple::x86); break;
710 Triple Triple::get64BitArchVariant() const {
713 case Triple::UnknownArch:
716 case Triple::cellspu:
717 case Triple::hexagon:
724 T.setArch(UnknownArch);
728 case Triple::mips64el:
731 case Triple::sparcv9:
736 case Triple::mips: T.setArch(Triple::mips64); break;
737 case Triple::mipsel: T.setArch(Triple::mips64el); break;
738 case Triple::ppc: T.setArch(Triple::ppc64); break;
739 case Triple::ptx32: T.setArch(Triple::ptx64); break;
740 case Triple::sparc: T.setArch(Triple::sparcv9); break;
741 case Triple::x86: T.setArch(Triple::x86_64); break;