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 aarch64_be: return "aarch64_be";
24 case arm: return "arm";
25 case armeb: return "armeb";
26 case arm64: return "arm64";
27 case hexagon: return "hexagon";
28 case mips: return "mips";
29 case mipsel: return "mipsel";
30 case mips64: return "mips64";
31 case mips64el: return "mips64el";
32 case msp430: return "msp430";
33 case ppc64: return "powerpc64";
34 case ppc64le: return "powerpc64le";
35 case ppc: return "powerpc";
36 case r600: return "r600";
37 case sparc: return "sparc";
38 case sparcv9: return "sparcv9";
39 case systemz: return "s390x";
40 case tce: return "tce";
41 case thumb: return "thumb";
42 case thumbeb: return "thumbeb";
43 case x86: return "i386";
44 case x86_64: return "x86_64";
45 case xcore: return "xcore";
46 case nvptx: return "nvptx";
47 case nvptx64: return "nvptx64";
48 case le32: return "le32";
49 case amdil: return "amdil";
50 case spir: return "spir";
51 case spir64: return "spir64";
54 llvm_unreachable("Invalid ArchType!");
57 const char *Triple::getArchTypePrefix(ArchType Kind) {
63 case aarch64_be: return "aarch64";
68 case thumbeb: return "arm";
70 case arm64: return "arm64";
74 case ppc: return "ppc";
79 case mips64el: return "mips";
81 case hexagon: return "hexagon";
83 case r600: return "r600";
86 case sparc: return "sparc";
88 case systemz: return "systemz";
91 case x86_64: return "x86";
93 case xcore: return "xcore";
95 case nvptx: return "nvptx";
96 case nvptx64: return "nvptx";
98 case le32: return "le32";
99 case amdil: return "amdil";
100 case spir: return "spir";
101 case spir64: return "spir";
105 const char *Triple::getVendorTypeName(VendorType Kind) {
107 case UnknownVendor: return "unknown";
109 case Apple: return "apple";
110 case PC: return "pc";
111 case SCEI: return "scei";
112 case BGP: return "bgp";
113 case BGQ: return "bgq";
114 case Freescale: return "fsl";
115 case IBM: return "ibm";
116 case NVIDIA: return "nvidia";
119 llvm_unreachable("Invalid VendorType!");
122 const char *Triple::getOSTypeName(OSType Kind) {
124 case UnknownOS: return "unknown";
126 case AuroraUX: return "auroraux";
127 case Cygwin: return "cygwin";
128 case Darwin: return "darwin";
129 case DragonFly: return "dragonfly";
130 case FreeBSD: return "freebsd";
131 case IOS: return "ios";
132 case KFreeBSD: return "kfreebsd";
133 case Linux: return "linux";
134 case Lv2: return "lv2";
135 case MacOSX: return "macosx";
136 case MinGW32: return "mingw32";
137 case NetBSD: return "netbsd";
138 case OpenBSD: return "openbsd";
139 case Solaris: return "solaris";
140 case Win32: return "windows";
141 case Haiku: return "haiku";
142 case Minix: return "minix";
143 case RTEMS: return "rtems";
144 case NaCl: return "nacl";
145 case CNK: return "cnk";
146 case Bitrig: return "bitrig";
147 case AIX: return "aix";
148 case CUDA: return "cuda";
149 case NVCL: return "nvcl";
152 llvm_unreachable("Invalid OSType");
155 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
157 case UnknownEnvironment: return "unknown";
158 case GNU: return "gnu";
159 case GNUEABIHF: return "gnueabihf";
160 case GNUEABI: return "gnueabi";
161 case GNUX32: return "gnux32";
162 case CODE16: return "code16";
163 case EABI: return "eabi";
164 case EABIHF: return "eabihf";
165 case Android: return "android";
166 case MSVC: return "msvc";
167 case Itanium: return "itanium";
168 case Cygnus: return "cygnus";
171 llvm_unreachable("Invalid EnvironmentType!");
174 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
175 return StringSwitch<Triple::ArchType>(Name)
176 .Case("aarch64", aarch64)
177 .Case("aarch64_be", aarch64_be)
179 .Case("armeb", armeb)
180 .Case("arm64", arm64)
182 .Case("mipsel", mipsel)
183 .Case("mips64", mips64)
184 .Case("mips64el", mips64el)
185 .Case("msp430", msp430)
186 .Case("ppc64", ppc64)
189 .Case("ppc64le", ppc64le)
191 .Case("hexagon", hexagon)
192 .Case("sparc", sparc)
193 .Case("sparcv9", sparcv9)
194 .Case("systemz", systemz)
196 .Case("thumb", thumb)
197 .Case("thumbeb", thumbeb)
199 .Case("x86-64", x86_64)
200 .Case("xcore", xcore)
201 .Case("nvptx", nvptx)
202 .Case("nvptx64", nvptx64)
204 .Case("amdil", amdil)
206 .Case("spir64", spir64)
207 .Default(UnknownArch);
210 // Returns architecture name that is understood by the target assembler.
211 const char *Triple::getArchNameForAssembler() {
212 if (!isOSDarwin() && getVendor() != Triple::Apple)
215 return StringSwitch<const char*>(getArchName())
216 .Case("i386", "i386")
217 .Case("x86_64", "x86_64")
218 .Case("powerpc", "ppc")
219 .Case("powerpc64", "ppc64")
220 .Case("powerpc64le", "ppc64le")
222 .Cases("armv4t", "thumbv4t", "armv4t")
223 .Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5")
224 .Cases("armv6", "thumbv6", "armv6")
225 .Cases("armv7", "thumbv7", "armv7")
226 .Case("armeb", "armeb")
227 .Case("arm64", "arm64")
228 .Case("r600", "r600")
229 .Case("nvptx", "nvptx")
230 .Case("nvptx64", "nvptx64")
231 .Case("le32", "le32")
232 .Case("amdil", "amdil")
233 .Case("spir", "spir")
234 .Case("spir64", "spir64")
238 static Triple::ArchType parseArch(StringRef ArchName) {
239 return StringSwitch<Triple::ArchType>(ArchName)
240 .Cases("i386", "i486", "i586", "i686", Triple::x86)
241 // FIXME: Do we need to support these?
242 .Cases("i786", "i886", "i986", Triple::x86)
243 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
244 .Case("powerpc", Triple::ppc)
245 .Cases("powerpc64", "ppu", Triple::ppc64)
246 .Case("powerpc64le", Triple::ppc64le)
247 .Case("aarch64", Triple::aarch64)
248 .Case("aarch64_be", Triple::aarch64_be)
249 .Cases("arm", "xscale", Triple::arm)
250 // FIXME: It would be good to replace these with explicit names for all the
251 // various suffixes supported.
252 .StartsWith("armv", Triple::arm)
253 .Case("armeb", Triple::armeb)
254 .StartsWith("armebv", Triple::armeb)
255 .Case("thumb", Triple::thumb)
256 .StartsWith("thumbv", Triple::thumb)
257 .Case("thumbeb", Triple::thumbeb)
258 .StartsWith("thumbebv", Triple::thumbeb)
259 .Case("arm64", Triple::arm64)
260 .Case("msp430", Triple::msp430)
261 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
262 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
263 .Cases("mips64", "mips64eb", Triple::mips64)
264 .Case("mips64el", Triple::mips64el)
265 .Case("r600", Triple::r600)
266 .Case("hexagon", Triple::hexagon)
267 .Case("s390x", Triple::systemz)
268 .Case("sparc", Triple::sparc)
269 .Cases("sparcv9", "sparc64", Triple::sparcv9)
270 .Case("tce", Triple::tce)
271 .Case("xcore", Triple::xcore)
272 .Case("nvptx", Triple::nvptx)
273 .Case("nvptx64", Triple::nvptx64)
274 .Case("le32", Triple::le32)
275 .Case("amdil", Triple::amdil)
276 .Case("spir", Triple::spir)
277 .Case("spir64", Triple::spir64)
278 .Default(Triple::UnknownArch);
281 static Triple::VendorType parseVendor(StringRef VendorName) {
282 return StringSwitch<Triple::VendorType>(VendorName)
283 .Case("apple", Triple::Apple)
284 .Case("pc", Triple::PC)
285 .Case("scei", Triple::SCEI)
286 .Case("bgp", Triple::BGP)
287 .Case("bgq", Triple::BGQ)
288 .Case("fsl", Triple::Freescale)
289 .Case("ibm", Triple::IBM)
290 .Case("nvidia", Triple::NVIDIA)
291 .Default(Triple::UnknownVendor);
294 static Triple::OSType parseOS(StringRef OSName) {
295 return StringSwitch<Triple::OSType>(OSName)
296 .StartsWith("auroraux", Triple::AuroraUX)
297 .StartsWith("cygwin", Triple::Cygwin)
298 .StartsWith("darwin", Triple::Darwin)
299 .StartsWith("dragonfly", Triple::DragonFly)
300 .StartsWith("freebsd", Triple::FreeBSD)
301 .StartsWith("ios", Triple::IOS)
302 .StartsWith("kfreebsd", Triple::KFreeBSD)
303 .StartsWith("linux", Triple::Linux)
304 .StartsWith("lv2", Triple::Lv2)
305 .StartsWith("macosx", Triple::MacOSX)
306 .StartsWith("mingw32", Triple::MinGW32)
307 .StartsWith("netbsd", Triple::NetBSD)
308 .StartsWith("openbsd", Triple::OpenBSD)
309 .StartsWith("solaris", Triple::Solaris)
310 .StartsWith("win32", Triple::Win32)
311 .StartsWith("windows", Triple::Win32)
312 .StartsWith("haiku", Triple::Haiku)
313 .StartsWith("minix", Triple::Minix)
314 .StartsWith("rtems", Triple::RTEMS)
315 .StartsWith("nacl", Triple::NaCl)
316 .StartsWith("cnk", Triple::CNK)
317 .StartsWith("bitrig", Triple::Bitrig)
318 .StartsWith("aix", Triple::AIX)
319 .StartsWith("cuda", Triple::CUDA)
320 .StartsWith("nvcl", Triple::NVCL)
321 .Default(Triple::UnknownOS);
324 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
325 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
326 .StartsWith("eabihf", Triple::EABIHF)
327 .StartsWith("eabi", Triple::EABI)
328 .StartsWith("gnueabihf", Triple::GNUEABIHF)
329 .StartsWith("gnueabi", Triple::GNUEABI)
330 .StartsWith("gnux32", Triple::GNUX32)
331 .StartsWith("code16", Triple::CODE16)
332 .StartsWith("gnu", Triple::GNU)
333 .StartsWith("android", Triple::Android)
334 .StartsWith("msvc", Triple::MSVC)
335 .StartsWith("itanium", Triple::Itanium)
336 .StartsWith("cygnus", Triple::Cygnus)
337 .Default(Triple::UnknownEnvironment);
340 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
341 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
342 .EndsWith("coff", Triple::COFF)
343 .EndsWith("elf", Triple::ELF)
344 .EndsWith("macho", Triple::MachO)
345 .Default(Triple::UnknownObjectFormat);
348 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
350 case Triple::UnknownObjectFormat: return "";
351 case Triple::COFF: return "coff";
352 case Triple::ELF: return "elf";
353 case Triple::MachO: return "macho";
355 llvm_unreachable("unknown object format type");
358 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
360 return Triple::MachO;
361 else if (T.isOSWindows())
366 /// \brief Construct a triple from the string representation provided.
368 /// This stores the string representation and parses the various pieces into
370 Triple::Triple(const Twine &Str)
372 Arch(parseArch(getArchName())),
373 Vendor(parseVendor(getVendorName())),
374 OS(parseOS(getOSName())),
375 Environment(parseEnvironment(getEnvironmentName())),
376 ObjectFormat(parseFormat(getEnvironmentName())) {
377 if (ObjectFormat == Triple::UnknownObjectFormat)
378 ObjectFormat = getDefaultFormat(*this);
381 /// \brief Construct a triple from string representations of the architecture,
384 /// This joins each argument into a canonical string representation and parses
385 /// them into enum members. It leaves the environment unknown and omits it from
386 /// the string representation.
387 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
388 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
389 Arch(parseArch(ArchStr.str())),
390 Vendor(parseVendor(VendorStr.str())),
391 OS(parseOS(OSStr.str())),
392 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
393 ObjectFormat = getDefaultFormat(*this);
396 /// \brief Construct a triple from string representations of the architecture,
397 /// vendor, OS, and environment.
399 /// This joins each argument into a canonical string representation and parses
400 /// them into enum members.
401 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
402 const Twine &EnvironmentStr)
403 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
404 EnvironmentStr).str()),
405 Arch(parseArch(ArchStr.str())),
406 Vendor(parseVendor(VendorStr.str())),
407 OS(parseOS(OSStr.str())),
408 Environment(parseEnvironment(EnvironmentStr.str())),
409 ObjectFormat(parseFormat(EnvironmentStr.str())) {
410 if (ObjectFormat == Triple::UnknownObjectFormat)
411 ObjectFormat = getDefaultFormat(*this);
414 std::string Triple::normalize(StringRef Str) {
415 // Parse into components.
416 SmallVector<StringRef, 4> Components;
417 Str.split(Components, "-");
419 // If the first component corresponds to a known architecture, preferentially
420 // use it for the architecture. If the second component corresponds to a
421 // known vendor, preferentially use it for the vendor, etc. This avoids silly
422 // component movement when a component parses as (eg) both a valid arch and a
424 ArchType Arch = UnknownArch;
425 if (Components.size() > 0)
426 Arch = parseArch(Components[0]);
427 VendorType Vendor = UnknownVendor;
428 if (Components.size() > 1)
429 Vendor = parseVendor(Components[1]);
430 OSType OS = UnknownOS;
431 if (Components.size() > 2)
432 OS = parseOS(Components[2]);
433 EnvironmentType Environment = UnknownEnvironment;
434 if (Components.size() > 3)
435 Environment = parseEnvironment(Components[3]);
436 ObjectFormatType ObjectFormat = UnknownObjectFormat;
437 if (Components.size() > 4)
438 ObjectFormat = parseFormat(Components[4]);
440 // Note which components are already in their final position. These will not
443 Found[0] = Arch != UnknownArch;
444 Found[1] = Vendor != UnknownVendor;
445 Found[2] = OS != UnknownOS;
446 Found[3] = Environment != UnknownEnvironment;
448 // If they are not there already, permute the components into their canonical
449 // positions by seeing if they parse as a valid architecture, and if so moving
450 // the component to the architecture position etc.
451 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
453 continue; // Already in the canonical position.
455 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
456 // Do not reparse any components that already matched.
457 if (Idx < array_lengthof(Found) && Found[Idx])
460 // Does this component parse as valid for the target position?
462 StringRef Comp = Components[Idx];
464 default: llvm_unreachable("unexpected component type!");
466 Arch = parseArch(Comp);
467 Valid = Arch != UnknownArch;
470 Vendor = parseVendor(Comp);
471 Valid = Vendor != UnknownVendor;
475 Valid = OS != UnknownOS;
478 Environment = parseEnvironment(Comp);
479 Valid = Environment != UnknownEnvironment;
481 ObjectFormat = parseFormat(Comp);
482 Valid = ObjectFormat != UnknownObjectFormat;
487 continue; // Nope, try the next component.
489 // Move the component to the target position, pushing any non-fixed
490 // components that are in the way to the right. This tends to give
491 // good results in the common cases of a forgotten vendor component
492 // or a wrongly positioned environment.
494 // Insert left, pushing the existing components to the right. For
495 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
496 StringRef CurrentComponent(""); // The empty component.
497 // Replace the component we are moving with an empty component.
498 std::swap(CurrentComponent, Components[Idx]);
499 // Insert the component being moved at Pos, displacing any existing
500 // components to the right.
501 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
502 // Skip over any fixed components.
503 while (i < array_lengthof(Found) && Found[i])
505 // Place the component at the new position, getting the component
506 // that was at this position - it will be moved right.
507 std::swap(CurrentComponent, Components[i]);
509 } else if (Pos > Idx) {
510 // Push right by inserting empty components until the component at Idx
511 // reaches the target position Pos. For example, pc-a -> -pc-a when
512 // moving pc to the second position.
514 // Insert one empty component at Idx.
515 StringRef CurrentComponent(""); // The empty component.
516 for (unsigned i = Idx; i < Components.size();) {
517 // Place the component at the new position, getting the component
518 // that was at this position - it will be moved right.
519 std::swap(CurrentComponent, Components[i]);
520 // If it was placed on top of an empty component then we are done.
521 if (CurrentComponent.empty())
523 // Advance to the next component, skipping any fixed components.
524 while (++i < array_lengthof(Found) && Found[i])
527 // The last component was pushed off the end - append it.
528 if (!CurrentComponent.empty())
529 Components.push_back(CurrentComponent);
531 // Advance Idx to the component's new position.
532 while (++Idx < array_lengthof(Found) && Found[Idx])
534 } while (Idx < Pos); // Add more until the final position is reached.
536 assert(Pos < Components.size() && Components[Pos] == Comp &&
537 "Component moved wrong!");
543 // Special case logic goes here. At this point Arch, Vendor and OS have the
544 // correct values for the computed components.
546 if (OS == Triple::Win32) {
547 Components.resize(4);
548 Components[2] = "windows";
549 if (Environment == UnknownEnvironment) {
550 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
551 Components[3] = "msvc";
553 Components[3] = getObjectFormatTypeName(ObjectFormat);
555 } else if (OS == Triple::MinGW32) {
556 Components.resize(4);
557 Components[2] = "windows";
558 Components[3] = "gnu";
559 } else if (OS == Triple::Cygwin) {
560 Components.resize(4);
561 Components[2] = "windows";
562 Components[3] = "cygnus";
564 if (OS == Triple::MinGW32 || OS == Triple::Cygwin ||
565 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
566 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
567 Components.resize(5);
568 Components[4] = getObjectFormatTypeName(ObjectFormat);
572 // Stick the corrected components back together to form the normalized string.
573 std::string Normalized;
574 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
575 if (i) Normalized += '-';
576 Normalized += Components[i];
581 StringRef Triple::getArchName() const {
582 return StringRef(Data).split('-').first; // Isolate first component
585 StringRef Triple::getVendorName() const {
586 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
587 return Tmp.split('-').first; // Isolate second component
590 StringRef Triple::getOSName() const {
591 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
592 Tmp = Tmp.split('-').second; // Strip second component
593 return Tmp.split('-').first; // Isolate third component
596 StringRef Triple::getEnvironmentName() const {
597 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
598 Tmp = Tmp.split('-').second; // Strip second component
599 return Tmp.split('-').second; // Strip third component
602 StringRef Triple::getOSAndEnvironmentName() const {
603 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
604 return Tmp.split('-').second; // Strip second component
607 static unsigned EatNumber(StringRef &Str) {
608 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
612 // Consume the leading digit.
613 Result = Result*10 + (Str[0] - '0');
617 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
622 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
623 unsigned &Micro) const {
624 StringRef OSName = getOSName();
626 // Assume that the OS portion of the triple starts with the canonical name.
627 StringRef OSTypeName = getOSTypeName(getOS());
628 if (OSName.startswith(OSTypeName))
629 OSName = OSName.substr(OSTypeName.size());
631 // Any unset version defaults to 0.
632 Major = Minor = Micro = 0;
634 // Parse up to three components.
635 unsigned *Components[3] = { &Major, &Minor, &Micro };
636 for (unsigned i = 0; i != 3; ++i) {
637 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
640 // Consume the leading number.
641 *Components[i] = EatNumber(OSName);
643 // Consume the separator, if present.
644 if (OSName.startswith("."))
645 OSName = OSName.substr(1);
649 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
650 unsigned &Micro) const {
651 getOSVersion(Major, Minor, Micro);
654 default: llvm_unreachable("unexpected OS for Darwin triple");
656 // Default to darwin8, i.e., MacOSX 10.4.
659 // Darwin version numbers are skewed from OS X versions.
676 // Ignore the version from the triple. This is only handled because the
677 // the clang driver combines OS X and IOS support into a common Darwin
678 // toolchain that wants to know the OS X version number even when targeting
688 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
689 unsigned &Micro) const {
691 default: llvm_unreachable("unexpected OS for Darwin triple");
694 // Ignore the version from the triple. This is only handled because the
695 // the clang driver combines OS X and IOS support into a common Darwin
696 // toolchain that wants to know the iOS version number even when targeting
703 getOSVersion(Major, Minor, Micro);
704 // Default to 5.0 (or 7.0 for arm64).
706 Major = (getArch() == arm64) ? 7 : 5;
711 void Triple::setTriple(const Twine &Str) {
715 void Triple::setArch(ArchType Kind) {
716 setArchName(getArchTypeName(Kind));
719 void Triple::setVendor(VendorType Kind) {
720 setVendorName(getVendorTypeName(Kind));
723 void Triple::setOS(OSType Kind) {
724 setOSName(getOSTypeName(Kind));
727 void Triple::setEnvironment(EnvironmentType Kind) {
728 setEnvironmentName(getEnvironmentTypeName(Kind));
731 void Triple::setObjectFormat(ObjectFormatType Kind) {
732 if (Environment == UnknownEnvironment)
733 return setEnvironmentName(getObjectFormatTypeName(Kind));
735 Twine Env = getEnvironmentTypeName(Environment) + Twine("-") +
736 getObjectFormatTypeName(Kind);
737 setEnvironmentName(Env.str());
740 void Triple::setArchName(StringRef Str) {
741 // Work around a miscompilation bug for Twines in gcc 4.0.3.
742 SmallString<64> Triple;
745 Triple += getVendorName();
747 Triple += getOSAndEnvironmentName();
748 setTriple(Triple.str());
751 void Triple::setVendorName(StringRef Str) {
752 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
755 void Triple::setOSName(StringRef Str) {
756 if (hasEnvironment())
757 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
758 "-" + getEnvironmentName());
760 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
763 void Triple::setEnvironmentName(StringRef Str) {
764 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
768 void Triple::setOSAndEnvironmentName(StringRef Str) {
769 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
772 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
774 case llvm::Triple::UnknownArch:
777 case llvm::Triple::msp430:
780 case llvm::Triple::amdil:
781 case llvm::Triple::arm:
782 case llvm::Triple::armeb:
783 case llvm::Triple::hexagon:
784 case llvm::Triple::le32:
785 case llvm::Triple::mips:
786 case llvm::Triple::mipsel:
787 case llvm::Triple::nvptx:
788 case llvm::Triple::ppc:
789 case llvm::Triple::r600:
790 case llvm::Triple::sparc:
791 case llvm::Triple::tce:
792 case llvm::Triple::thumb:
793 case llvm::Triple::thumbeb:
794 case llvm::Triple::x86:
795 case llvm::Triple::xcore:
796 case llvm::Triple::spir:
799 case llvm::Triple::arm64:
800 case llvm::Triple::aarch64:
801 case llvm::Triple::aarch64_be:
802 case llvm::Triple::mips64:
803 case llvm::Triple::mips64el:
804 case llvm::Triple::nvptx64:
805 case llvm::Triple::ppc64:
806 case llvm::Triple::ppc64le:
807 case llvm::Triple::sparcv9:
808 case llvm::Triple::systemz:
809 case llvm::Triple::x86_64:
810 case llvm::Triple::spir64:
813 llvm_unreachable("Invalid architecture value");
816 bool Triple::isArch64Bit() const {
817 return getArchPointerBitWidth(getArch()) == 64;
820 bool Triple::isArch32Bit() const {
821 return getArchPointerBitWidth(getArch()) == 32;
824 bool Triple::isArch16Bit() const {
825 return getArchPointerBitWidth(getArch()) == 16;
828 Triple Triple::get32BitArchVariant() const {
831 case Triple::UnknownArch:
832 case Triple::aarch64:
833 case Triple::aarch64_be:
836 case Triple::systemz:
837 case Triple::ppc64le:
838 T.setArch(UnknownArch);
845 case Triple::hexagon:
855 case Triple::thumbeb:
861 case Triple::mips64: T.setArch(Triple::mips); break;
862 case Triple::mips64el: T.setArch(Triple::mipsel); break;
863 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
864 case Triple::ppc64: T.setArch(Triple::ppc); break;
865 case Triple::sparcv9: T.setArch(Triple::sparc); break;
866 case Triple::x86_64: T.setArch(Triple::x86); break;
867 case Triple::spir64: T.setArch(Triple::spir); break;
872 Triple Triple::get64BitArchVariant() const {
875 case Triple::UnknownArch:
879 case Triple::hexagon:
885 case Triple::thumbeb:
887 T.setArch(UnknownArch);
890 case Triple::aarch64:
891 case Triple::aarch64_be:
894 case Triple::mips64el:
895 case Triple::nvptx64:
897 case Triple::ppc64le:
898 case Triple::sparcv9:
899 case Triple::systemz:
905 case Triple::mips: T.setArch(Triple::mips64); break;
906 case Triple::mipsel: T.setArch(Triple::mips64el); break;
907 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
908 case Triple::ppc: T.setArch(Triple::ppc64); break;
909 case Triple::sparc: T.setArch(Triple::sparcv9); break;
910 case Triple::x86: T.setArch(Triple::x86_64); break;
911 case Triple::spir: T.setArch(Triple::spir64); break;