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"
15 #include "llvm/Support/TargetParser.h"
16 #include "llvm/Support/Host.h"
20 const char *Triple::getArchTypeName(ArchType Kind) {
22 case UnknownArch: return "unknown";
24 case aarch64: return "aarch64";
25 case aarch64_be: return "aarch64_be";
26 case arm: return "arm";
27 case armeb: return "armeb";
28 case avr: return "avr";
29 case bpfel: return "bpfel";
30 case bpfeb: return "bpfeb";
31 case hexagon: return "hexagon";
32 case mips: return "mips";
33 case mipsel: return "mipsel";
34 case mips64: return "mips64";
35 case mips64el: return "mips64el";
36 case msp430: return "msp430";
37 case ppc64: return "powerpc64";
38 case ppc64le: return "powerpc64le";
39 case ppc: return "powerpc";
40 case r600: return "r600";
41 case amdgcn: return "amdgcn";
42 case sparc: return "sparc";
43 case sparcv9: return "sparcv9";
44 case sparcel: return "sparcel";
45 case systemz: return "s390x";
46 case tce: return "tce";
47 case thumb: return "thumb";
48 case thumbeb: return "thumbeb";
49 case x86: return "i386";
50 case x86_64: return "x86_64";
51 case xcore: return "xcore";
52 case nvptx: return "nvptx";
53 case nvptx64: return "nvptx64";
54 case le32: return "le32";
55 case le64: return "le64";
56 case amdil: return "amdil";
57 case amdil64: return "amdil64";
58 case hsail: return "hsail";
59 case hsail64: return "hsail64";
60 case spir: return "spir";
61 case spir64: return "spir64";
62 case kalimba: return "kalimba";
63 case lanai: return "lanai";
64 case shave: return "shave";
65 case wasm32: return "wasm32";
66 case wasm64: return "wasm64";
67 case renderscript32: return "renderscript32";
68 case renderscript64: return "renderscript64";
71 llvm_unreachable("Invalid ArchType!");
74 const char *Triple::getArchTypePrefix(ArchType Kind) {
80 case aarch64_be: return "aarch64";
85 case thumbeb: return "arm";
87 case avr: return "avr";
91 case ppc: return "ppc";
96 case mips64el: return "mips";
98 case hexagon: return "hexagon";
100 case amdgcn: return "amdgcn";
101 case r600: return "r600";
104 case bpfeb: return "bpf";
108 case sparc: return "sparc";
110 case systemz: return "s390";
113 case x86_64: return "x86";
115 case xcore: return "xcore";
117 // NVPTX intrinsics are namespaced under nvvm.
118 case nvptx: return "nvvm";
119 case nvptx64: return "nvvm";
121 case le32: return "le32";
122 case le64: return "le64";
125 case amdil64: return "amdil";
128 case hsail64: return "hsail";
131 case spir64: return "spir";
132 case kalimba: return "kalimba";
133 case lanai: return "lanai";
134 case shave: return "shave";
136 case wasm64: return "wasm";
140 const char *Triple::getVendorTypeName(VendorType Kind) {
142 case UnknownVendor: return "unknown";
144 case Apple: return "apple";
145 case PC: return "pc";
146 case SCEI: return "scei";
147 case BGP: return "bgp";
148 case BGQ: return "bgq";
149 case Freescale: return "fsl";
150 case IBM: return "ibm";
151 case ImaginationTechnologies: return "img";
152 case MipsTechnologies: return "mti";
153 case NVIDIA: return "nvidia";
154 case CSR: return "csr";
155 case Myriad: return "myriad";
156 case AMD: return "amd";
157 case Mesa: return "mesa";
160 llvm_unreachable("Invalid VendorType!");
163 const char *Triple::getOSTypeName(OSType Kind) {
165 case UnknownOS: return "unknown";
167 case CloudABI: return "cloudabi";
168 case Darwin: return "darwin";
169 case DragonFly: return "dragonfly";
170 case FreeBSD: return "freebsd";
171 case IOS: return "ios";
172 case KFreeBSD: return "kfreebsd";
173 case Linux: return "linux";
174 case Lv2: return "lv2";
175 case MacOSX: return "macosx";
176 case NetBSD: return "netbsd";
177 case OpenBSD: return "openbsd";
178 case Solaris: return "solaris";
179 case Win32: return "windows";
180 case Haiku: return "haiku";
181 case Minix: return "minix";
182 case RTEMS: return "rtems";
183 case NaCl: return "nacl";
184 case CNK: return "cnk";
185 case Bitrig: return "bitrig";
186 case AIX: return "aix";
187 case CUDA: return "cuda";
188 case NVCL: return "nvcl";
189 case AMDHSA: return "amdhsa";
190 case PS4: return "ps4";
191 case ELFIAMCU: return "elfiamcu";
192 case TvOS: return "tvos";
193 case WatchOS: return "watchos";
194 case Mesa3D: return "mesa3d";
197 llvm_unreachable("Invalid OSType");
200 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
202 case UnknownEnvironment: return "unknown";
203 case GNU: return "gnu";
204 case GNUABI64: return "gnuabi64";
205 case GNUEABIHF: return "gnueabihf";
206 case GNUEABI: return "gnueabi";
207 case GNUX32: return "gnux32";
208 case CODE16: return "code16";
209 case EABI: return "eabi";
210 case EABIHF: return "eabihf";
211 case Android: return "android";
212 case Musl: return "musl";
213 case MuslEABI: return "musleabi";
214 case MuslEABIHF: return "musleabihf";
215 case MSVC: return "msvc";
216 case Itanium: return "itanium";
217 case Cygnus: return "cygnus";
218 case AMDOpenCL: return "amdopencl";
219 case CoreCLR: return "coreclr";
222 llvm_unreachable("Invalid EnvironmentType!");
225 static Triple::ArchType parseBPFArch(StringRef ArchName) {
226 if (ArchName.equals("bpf")) {
227 if (sys::IsLittleEndianHost)
228 return Triple::bpfel;
230 return Triple::bpfeb;
231 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
232 return Triple::bpfeb;
233 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
234 return Triple::bpfel;
236 return Triple::UnknownArch;
240 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
241 Triple::ArchType BPFArch(parseBPFArch(Name));
242 return StringSwitch<Triple::ArchType>(Name)
243 .Case("aarch64", aarch64)
244 .Case("aarch64_be", aarch64_be)
245 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
247 .Case("armeb", armeb)
249 .StartsWith("bpf", BPFArch)
251 .Case("mipsel", mipsel)
252 .Case("mips64", mips64)
253 .Case("mips64el", mips64el)
254 .Case("msp430", msp430)
255 .Case("ppc64", ppc64)
258 .Case("ppc64le", ppc64le)
260 .Case("amdgcn", amdgcn)
261 .Case("hexagon", hexagon)
262 .Case("sparc", sparc)
263 .Case("sparcel", sparcel)
264 .Case("sparcv9", sparcv9)
265 .Case("systemz", systemz)
267 .Case("thumb", thumb)
268 .Case("thumbeb", thumbeb)
270 .Case("x86-64", x86_64)
271 .Case("xcore", xcore)
272 .Case("nvptx", nvptx)
273 .Case("nvptx64", nvptx64)
276 .Case("amdil", amdil)
277 .Case("amdil64", amdil64)
278 .Case("hsail", hsail)
279 .Case("hsail64", hsail64)
281 .Case("spir64", spir64)
282 .Case("kalimba", kalimba)
283 .Case("lanai", lanai)
284 .Case("shave", shave)
285 .Case("wasm32", wasm32)
286 .Case("wasm64", wasm64)
287 .Case("renderscript32", renderscript32)
288 .Case("renderscript64", renderscript64)
289 .Default(UnknownArch);
292 static Triple::ArchType parseARMArch(StringRef ArchName) {
293 unsigned ISA = ARM::parseArchISA(ArchName);
294 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
296 Triple::ArchType arch = Triple::UnknownArch;
298 case ARM::EK_LITTLE: {
304 arch = Triple::thumb;
306 case ARM::IK_AARCH64:
307 arch = Triple::aarch64;
315 arch = Triple::armeb;
318 arch = Triple::thumbeb;
320 case ARM::IK_AARCH64:
321 arch = Triple::aarch64_be;
328 ArchName = ARM::getCanonicalArchName(ArchName);
329 if (ArchName.empty())
330 return Triple::UnknownArch;
332 // Thumb only exists in v4+
333 if (ISA == ARM::IK_THUMB &&
334 (ArchName.startswith("v2") || ArchName.startswith("v3")))
335 return Triple::UnknownArch;
337 // Thumb only for v6m
338 unsigned Profile = ARM::parseArchProfile(ArchName);
339 unsigned Version = ARM::parseArchVersion(ArchName);
340 if (Profile == ARM::PK_M && Version == 6) {
341 if (ENDIAN == ARM::EK_BIG)
342 return Triple::thumbeb;
344 return Triple::thumb;
350 static Triple::ArchType parseArch(StringRef ArchName) {
351 auto AT = StringSwitch<Triple::ArchType>(ArchName)
352 .Cases("i386", "i486", "i586", "i686", Triple::x86)
353 // FIXME: Do we need to support these?
354 .Cases("i786", "i886", "i986", Triple::x86)
355 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
356 .Cases("powerpc", "ppc32", Triple::ppc)
357 .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)
358 .Cases("powerpc64le", "ppc64le", Triple::ppc64le)
359 .Case("xscale", Triple::arm)
360 .Case("xscaleeb", Triple::armeb)
361 .Case("aarch64", Triple::aarch64)
362 .Case("aarch64_be", Triple::aarch64_be)
363 .Case("arm64", Triple::aarch64)
364 .Case("arm", Triple::arm)
365 .Case("armeb", Triple::armeb)
366 .Case("thumb", Triple::thumb)
367 .Case("thumbeb", Triple::thumbeb)
368 .Case("avr", Triple::avr)
369 .Case("msp430", Triple::msp430)
370 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
371 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
372 .Cases("mips64", "mips64eb", Triple::mips64)
373 .Case("mips64el", Triple::mips64el)
374 .Case("r600", Triple::r600)
375 .Case("amdgcn", Triple::amdgcn)
376 .Case("hexagon", Triple::hexagon)
377 .Cases("s390x", "systemz", Triple::systemz)
378 .Case("sparc", Triple::sparc)
379 .Case("sparcel", Triple::sparcel)
380 .Cases("sparcv9", "sparc64", Triple::sparcv9)
381 .Case("tce", Triple::tce)
382 .Case("xcore", Triple::xcore)
383 .Case("nvptx", Triple::nvptx)
384 .Case("nvptx64", Triple::nvptx64)
385 .Case("le32", Triple::le32)
386 .Case("le64", Triple::le64)
387 .Case("amdil", Triple::amdil)
388 .Case("amdil64", Triple::amdil64)
389 .Case("hsail", Triple::hsail)
390 .Case("hsail64", Triple::hsail64)
391 .Case("spir", Triple::spir)
392 .Case("spir64", Triple::spir64)
393 .StartsWith("kalimba", Triple::kalimba)
394 .Case("lanai", Triple::lanai)
395 .Case("shave", Triple::shave)
396 .Case("wasm32", Triple::wasm32)
397 .Case("wasm64", Triple::wasm64)
398 .Case("renderscript32", Triple::renderscript32)
399 .Case("renderscript64", Triple::renderscript64)
400 .Default(Triple::UnknownArch);
402 // Some architectures require special parsing logic just to compute the
404 if (AT == Triple::UnknownArch) {
405 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
406 ArchName.startswith("aarch64"))
407 return parseARMArch(ArchName);
408 if (ArchName.startswith("bpf"))
409 return parseBPFArch(ArchName);
415 static Triple::VendorType parseVendor(StringRef VendorName) {
416 return StringSwitch<Triple::VendorType>(VendorName)
417 .Case("apple", Triple::Apple)
418 .Case("pc", Triple::PC)
419 .Case("scei", Triple::SCEI)
420 .Case("bgp", Triple::BGP)
421 .Case("bgq", Triple::BGQ)
422 .Case("fsl", Triple::Freescale)
423 .Case("ibm", Triple::IBM)
424 .Case("img", Triple::ImaginationTechnologies)
425 .Case("mti", Triple::MipsTechnologies)
426 .Case("nvidia", Triple::NVIDIA)
427 .Case("csr", Triple::CSR)
428 .Case("myriad", Triple::Myriad)
429 .Case("amd", Triple::AMD)
430 .Case("mesa", Triple::Mesa)
431 .Default(Triple::UnknownVendor);
434 static Triple::OSType parseOS(StringRef OSName) {
435 return StringSwitch<Triple::OSType>(OSName)
436 .StartsWith("cloudabi", Triple::CloudABI)
437 .StartsWith("darwin", Triple::Darwin)
438 .StartsWith("dragonfly", Triple::DragonFly)
439 .StartsWith("freebsd", Triple::FreeBSD)
440 .StartsWith("ios", Triple::IOS)
441 .StartsWith("kfreebsd", Triple::KFreeBSD)
442 .StartsWith("linux", Triple::Linux)
443 .StartsWith("lv2", Triple::Lv2)
444 .StartsWith("macosx", Triple::MacOSX)
445 .StartsWith("netbsd", Triple::NetBSD)
446 .StartsWith("openbsd", Triple::OpenBSD)
447 .StartsWith("solaris", Triple::Solaris)
448 .StartsWith("win32", Triple::Win32)
449 .StartsWith("windows", Triple::Win32)
450 .StartsWith("haiku", Triple::Haiku)
451 .StartsWith("minix", Triple::Minix)
452 .StartsWith("rtems", Triple::RTEMS)
453 .StartsWith("nacl", Triple::NaCl)
454 .StartsWith("cnk", Triple::CNK)
455 .StartsWith("bitrig", Triple::Bitrig)
456 .StartsWith("aix", Triple::AIX)
457 .StartsWith("cuda", Triple::CUDA)
458 .StartsWith("nvcl", Triple::NVCL)
459 .StartsWith("amdhsa", Triple::AMDHSA)
460 .StartsWith("ps4", Triple::PS4)
461 .StartsWith("elfiamcu", Triple::ELFIAMCU)
462 .StartsWith("tvos", Triple::TvOS)
463 .StartsWith("watchos", Triple::WatchOS)
464 .StartsWith("mesa3d", Triple::Mesa3D)
465 .Default(Triple::UnknownOS);
468 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
469 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
470 .StartsWith("eabihf", Triple::EABIHF)
471 .StartsWith("eabi", Triple::EABI)
472 .StartsWith("gnuabi64", Triple::GNUABI64)
473 .StartsWith("gnueabihf", Triple::GNUEABIHF)
474 .StartsWith("gnueabi", Triple::GNUEABI)
475 .StartsWith("gnux32", Triple::GNUX32)
476 .StartsWith("code16", Triple::CODE16)
477 .StartsWith("gnu", Triple::GNU)
478 .StartsWith("android", Triple::Android)
479 .StartsWith("musleabihf", Triple::MuslEABIHF)
480 .StartsWith("musleabi", Triple::MuslEABI)
481 .StartsWith("musl", Triple::Musl)
482 .StartsWith("msvc", Triple::MSVC)
483 .StartsWith("itanium", Triple::Itanium)
484 .StartsWith("cygnus", Triple::Cygnus)
485 .StartsWith("amdopencl", Triple::AMDOpenCL)
486 .StartsWith("coreclr", Triple::CoreCLR)
487 .Default(Triple::UnknownEnvironment);
490 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
491 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
492 .EndsWith("coff", Triple::COFF)
493 .EndsWith("elf", Triple::ELF)
494 .EndsWith("macho", Triple::MachO)
495 .Default(Triple::UnknownObjectFormat);
498 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
499 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
501 // For now, this is the small part. Early return.
502 if (ARMSubArch.empty())
503 return StringSwitch<Triple::SubArchType>(SubArchName)
504 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
505 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
506 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
507 .Default(Triple::NoSubArch);
510 switch(ARM::parseArch(ARMSubArch)) {
512 return Triple::NoSubArch;
514 return Triple::ARMSubArch_v4t;
516 return Triple::ARMSubArch_v5;
517 case ARM::AK_ARMV5TE:
519 case ARM::AK_IWMMXT2:
521 case ARM::AK_ARMV5TEJ:
522 return Triple::ARMSubArch_v5te;
524 return Triple::ARMSubArch_v6;
526 case ARM::AK_ARMV6KZ:
527 return Triple::ARMSubArch_v6k;
528 case ARM::AK_ARMV6T2:
529 return Triple::ARMSubArch_v6t2;
531 return Triple::ARMSubArch_v6m;
534 return Triple::ARMSubArch_v7;
536 return Triple::ARMSubArch_v7k;
538 return Triple::ARMSubArch_v7m;
540 return Triple::ARMSubArch_v7s;
541 case ARM::AK_ARMV7EM:
542 return Triple::ARMSubArch_v7em;
544 return Triple::ARMSubArch_v8;
545 case ARM::AK_ARMV8_1A:
546 return Triple::ARMSubArch_v8_1a;
547 case ARM::AK_ARMV8_2A:
548 return Triple::ARMSubArch_v8_2a;
549 case ARM::AK_ARMV8MBaseline:
550 return Triple::ARMSubArch_v8m_baseline;
551 case ARM::AK_ARMV8MMainline:
552 return Triple::ARMSubArch_v8m_mainline;
554 return Triple::NoSubArch;
558 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
560 case Triple::UnknownObjectFormat: return "";
561 case Triple::COFF: return "coff";
562 case Triple::ELF: return "elf";
563 case Triple::MachO: return "macho";
565 llvm_unreachable("unknown object format type");
568 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
569 switch (T.getArch()) {
570 case Triple::UnknownArch:
571 case Triple::aarch64:
577 return Triple::MachO;
578 else if (T.isOSWindows())
582 case Triple::aarch64_be:
585 case Triple::amdil64:
590 case Triple::hexagon:
593 case Triple::hsail64:
594 case Triple::kalimba:
599 case Triple::mips64el:
603 case Triple::nvptx64:
604 case Triple::ppc64le:
606 case Triple::renderscript32:
607 case Triple::renderscript64:
610 case Triple::sparcel:
611 case Triple::sparcv9:
614 case Triple::systemz:
616 case Triple::thumbeb:
625 return Triple::MachO;
628 llvm_unreachable("unknown architecture");
631 /// \brief Construct a triple from the string representation provided.
633 /// This stores the string representation and parses the various pieces into
635 Triple::Triple(const Twine &Str)
636 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
637 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
638 ObjectFormat(UnknownObjectFormat) {
639 // Do minimal parsing by hand here.
640 SmallVector<StringRef, 4> Components;
641 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
642 if (Components.size() > 0) {
643 Arch = parseArch(Components[0]);
644 SubArch = parseSubArch(Components[0]);
645 if (Components.size() > 1) {
646 Vendor = parseVendor(Components[1]);
647 if (Components.size() > 2) {
648 OS = parseOS(Components[2]);
649 if (Components.size() > 3) {
650 Environment = parseEnvironment(Components[3]);
651 ObjectFormat = parseFormat(Components[3]);
656 if (ObjectFormat == UnknownObjectFormat)
657 ObjectFormat = getDefaultFormat(*this);
660 /// \brief Construct a triple from string representations of the architecture,
663 /// This joins each argument into a canonical string representation and parses
664 /// them into enum members. It leaves the environment unknown and omits it from
665 /// the string representation.
666 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
667 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
668 Arch(parseArch(ArchStr.str())),
669 SubArch(parseSubArch(ArchStr.str())),
670 Vendor(parseVendor(VendorStr.str())),
671 OS(parseOS(OSStr.str())),
672 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
673 ObjectFormat = getDefaultFormat(*this);
676 /// \brief Construct a triple from string representations of the architecture,
677 /// vendor, OS, and environment.
679 /// This joins each argument into a canonical string representation and parses
680 /// them into enum members.
681 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
682 const Twine &EnvironmentStr)
683 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
684 EnvironmentStr).str()),
685 Arch(parseArch(ArchStr.str())),
686 SubArch(parseSubArch(ArchStr.str())),
687 Vendor(parseVendor(VendorStr.str())),
688 OS(parseOS(OSStr.str())),
689 Environment(parseEnvironment(EnvironmentStr.str())),
690 ObjectFormat(parseFormat(EnvironmentStr.str())) {
691 if (ObjectFormat == Triple::UnknownObjectFormat)
692 ObjectFormat = getDefaultFormat(*this);
695 std::string Triple::normalize(StringRef Str) {
696 bool IsMinGW32 = false;
697 bool IsCygwin = false;
699 // Parse into components.
700 SmallVector<StringRef, 4> Components;
701 Str.split(Components, '-');
703 // If the first component corresponds to a known architecture, preferentially
704 // use it for the architecture. If the second component corresponds to a
705 // known vendor, preferentially use it for the vendor, etc. This avoids silly
706 // component movement when a component parses as (eg) both a valid arch and a
708 ArchType Arch = UnknownArch;
709 if (Components.size() > 0)
710 Arch = parseArch(Components[0]);
711 VendorType Vendor = UnknownVendor;
712 if (Components.size() > 1)
713 Vendor = parseVendor(Components[1]);
714 OSType OS = UnknownOS;
715 if (Components.size() > 2) {
716 OS = parseOS(Components[2]);
717 IsCygwin = Components[2].startswith("cygwin");
718 IsMinGW32 = Components[2].startswith("mingw");
720 EnvironmentType Environment = UnknownEnvironment;
721 if (Components.size() > 3)
722 Environment = parseEnvironment(Components[3]);
723 ObjectFormatType ObjectFormat = UnknownObjectFormat;
724 if (Components.size() > 4)
725 ObjectFormat = parseFormat(Components[4]);
727 // Note which components are already in their final position. These will not
730 Found[0] = Arch != UnknownArch;
731 Found[1] = Vendor != UnknownVendor;
732 Found[2] = OS != UnknownOS;
733 Found[3] = Environment != UnknownEnvironment;
735 // If they are not there already, permute the components into their canonical
736 // positions by seeing if they parse as a valid architecture, and if so moving
737 // the component to the architecture position etc.
738 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
740 continue; // Already in the canonical position.
742 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
743 // Do not reparse any components that already matched.
744 if (Idx < array_lengthof(Found) && Found[Idx])
747 // Does this component parse as valid for the target position?
749 StringRef Comp = Components[Idx];
751 default: llvm_unreachable("unexpected component type!");
753 Arch = parseArch(Comp);
754 Valid = Arch != UnknownArch;
757 Vendor = parseVendor(Comp);
758 Valid = Vendor != UnknownVendor;
762 IsCygwin = Comp.startswith("cygwin");
763 IsMinGW32 = Comp.startswith("mingw");
764 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
767 Environment = parseEnvironment(Comp);
768 Valid = Environment != UnknownEnvironment;
770 ObjectFormat = parseFormat(Comp);
771 Valid = ObjectFormat != UnknownObjectFormat;
776 continue; // Nope, try the next component.
778 // Move the component to the target position, pushing any non-fixed
779 // components that are in the way to the right. This tends to give
780 // good results in the common cases of a forgotten vendor component
781 // or a wrongly positioned environment.
783 // Insert left, pushing the existing components to the right. For
784 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
785 StringRef CurrentComponent(""); // The empty component.
786 // Replace the component we are moving with an empty component.
787 std::swap(CurrentComponent, Components[Idx]);
788 // Insert the component being moved at Pos, displacing any existing
789 // components to the right.
790 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
791 // Skip over any fixed components.
792 while (i < array_lengthof(Found) && Found[i])
794 // Place the component at the new position, getting the component
795 // that was at this position - it will be moved right.
796 std::swap(CurrentComponent, Components[i]);
798 } else if (Pos > Idx) {
799 // Push right by inserting empty components until the component at Idx
800 // reaches the target position Pos. For example, pc-a -> -pc-a when
801 // moving pc to the second position.
803 // Insert one empty component at Idx.
804 StringRef CurrentComponent(""); // The empty component.
805 for (unsigned i = Idx; i < Components.size();) {
806 // Place the component at the new position, getting the component
807 // that was at this position - it will be moved right.
808 std::swap(CurrentComponent, Components[i]);
809 // If it was placed on top of an empty component then we are done.
810 if (CurrentComponent.empty())
812 // Advance to the next component, skipping any fixed components.
813 while (++i < array_lengthof(Found) && Found[i])
816 // The last component was pushed off the end - append it.
817 if (!CurrentComponent.empty())
818 Components.push_back(CurrentComponent);
820 // Advance Idx to the component's new position.
821 while (++Idx < array_lengthof(Found) && Found[Idx])
823 } while (Idx < Pos); // Add more until the final position is reached.
825 assert(Pos < Components.size() && Components[Pos] == Comp &&
826 "Component moved wrong!");
832 // Special case logic goes here. At this point Arch, Vendor and OS have the
833 // correct values for the computed components.
834 std::string NormalizedEnvironment;
835 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
836 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
837 if (AndroidVersion.empty()) {
838 Components[3] = "android";
840 NormalizedEnvironment = Twine("android", AndroidVersion).str();
841 Components[3] = NormalizedEnvironment;
845 if (OS == Triple::Win32) {
846 Components.resize(4);
847 Components[2] = "windows";
848 if (Environment == UnknownEnvironment) {
849 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
850 Components[3] = "msvc";
852 Components[3] = getObjectFormatTypeName(ObjectFormat);
854 } else if (IsMinGW32) {
855 Components.resize(4);
856 Components[2] = "windows";
857 Components[3] = "gnu";
858 } else if (IsCygwin) {
859 Components.resize(4);
860 Components[2] = "windows";
861 Components[3] = "cygnus";
863 if (IsMinGW32 || IsCygwin ||
864 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
865 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
866 Components.resize(5);
867 Components[4] = getObjectFormatTypeName(ObjectFormat);
871 // Stick the corrected components back together to form the normalized string.
872 std::string Normalized;
873 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
874 if (i) Normalized += '-';
875 Normalized += Components[i];
880 StringRef Triple::getArchName() const {
881 return StringRef(Data).split('-').first; // Isolate first component
884 StringRef Triple::getVendorName() const {
885 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
886 return Tmp.split('-').first; // Isolate second component
889 StringRef Triple::getOSName() const {
890 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
891 Tmp = Tmp.split('-').second; // Strip second component
892 return Tmp.split('-').first; // Isolate third component
895 StringRef Triple::getEnvironmentName() const {
896 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
897 Tmp = Tmp.split('-').second; // Strip second component
898 return Tmp.split('-').second; // Strip third component
901 StringRef Triple::getOSAndEnvironmentName() const {
902 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
903 return Tmp.split('-').second; // Strip second component
906 static unsigned EatNumber(StringRef &Str) {
907 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
911 // Consume the leading digit.
912 Result = Result*10 + (Str[0] - '0');
916 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
921 static void parseVersionFromName(StringRef Name, unsigned &Major,
922 unsigned &Minor, unsigned &Micro) {
923 // Any unset version defaults to 0.
924 Major = Minor = Micro = 0;
926 // Parse up to three components.
927 unsigned *Components[3] = {&Major, &Minor, &Micro};
928 for (unsigned i = 0; i != 3; ++i) {
929 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
932 // Consume the leading number.
933 *Components[i] = EatNumber(Name);
935 // Consume the separator, if present.
936 if (Name.startswith("."))
937 Name = Name.substr(1);
941 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
942 unsigned &Micro) const {
943 StringRef EnvironmentName = getEnvironmentName();
944 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
945 if (EnvironmentName.startswith(EnvironmentTypeName))
946 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
948 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
951 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
952 unsigned &Micro) const {
953 StringRef OSName = getOSName();
954 // Assume that the OS portion of the triple starts with the canonical name.
955 StringRef OSTypeName = getOSTypeName(getOS());
956 if (OSName.startswith(OSTypeName))
957 OSName = OSName.substr(OSTypeName.size());
959 parseVersionFromName(OSName, Major, Minor, Micro);
962 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
963 unsigned &Micro) const {
964 getOSVersion(Major, Minor, Micro);
967 default: llvm_unreachable("unexpected OS for Darwin triple");
969 // Default to darwin8, i.e., MacOSX 10.4.
972 // Darwin version numbers are skewed from OS X versions.
991 // Ignore the version from the triple. This is only handled because the
992 // the clang driver combines OS X and IOS support into a common Darwin
993 // toolchain that wants to know the OS X version number even when targeting
1003 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
1004 unsigned &Micro) const {
1006 default: llvm_unreachable("unexpected OS for Darwin triple");
1009 // Ignore the version from the triple. This is only handled because the
1010 // the clang driver combines OS X and IOS support into a common Darwin
1011 // toolchain that wants to know the iOS version number even when targeting
1019 getOSVersion(Major, Minor, Micro);
1020 // Default to 5.0 (or 7.0 for arm64).
1022 Major = (getArch() == aarch64) ? 7 : 5;
1025 llvm_unreachable("conflicting triple info");
1029 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
1030 unsigned &Micro) const {
1032 default: llvm_unreachable("unexpected OS for Darwin triple");
1035 // Ignore the version from the triple. This is only handled because the
1036 // the clang driver combines OS X and IOS support into a common Darwin
1037 // toolchain that wants to know the iOS version number even when targeting
1044 getOSVersion(Major, Minor, Micro);
1049 llvm_unreachable("conflicting triple info");
1053 void Triple::setTriple(const Twine &Str) {
1054 *this = Triple(Str);
1057 void Triple::setArch(ArchType Kind) {
1058 setArchName(getArchTypeName(Kind));
1061 void Triple::setVendor(VendorType Kind) {
1062 setVendorName(getVendorTypeName(Kind));
1065 void Triple::setOS(OSType Kind) {
1066 setOSName(getOSTypeName(Kind));
1069 void Triple::setEnvironment(EnvironmentType Kind) {
1070 if (ObjectFormat == getDefaultFormat(*this))
1071 return setEnvironmentName(getEnvironmentTypeName(Kind));
1073 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1074 getObjectFormatTypeName(ObjectFormat)).str());
1077 void Triple::setObjectFormat(ObjectFormatType Kind) {
1078 if (Environment == UnknownEnvironment)
1079 return setEnvironmentName(getObjectFormatTypeName(Kind));
1081 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1082 getObjectFormatTypeName(Kind)).str());
1085 void Triple::setArchName(StringRef Str) {
1086 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1087 SmallString<64> Triple;
1090 Triple += getVendorName();
1092 Triple += getOSAndEnvironmentName();
1096 void Triple::setVendorName(StringRef Str) {
1097 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1100 void Triple::setOSName(StringRef Str) {
1101 if (hasEnvironment())
1102 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1103 "-" + getEnvironmentName());
1105 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1108 void Triple::setEnvironmentName(StringRef Str) {
1109 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1113 void Triple::setOSAndEnvironmentName(StringRef Str) {
1114 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1117 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1119 case llvm::Triple::UnknownArch:
1122 case llvm::Triple::avr:
1123 case llvm::Triple::msp430:
1126 case llvm::Triple::arm:
1127 case llvm::Triple::armeb:
1128 case llvm::Triple::hexagon:
1129 case llvm::Triple::le32:
1130 case llvm::Triple::mips:
1131 case llvm::Triple::mipsel:
1132 case llvm::Triple::nvptx:
1133 case llvm::Triple::ppc:
1134 case llvm::Triple::r600:
1135 case llvm::Triple::sparc:
1136 case llvm::Triple::sparcel:
1137 case llvm::Triple::tce:
1138 case llvm::Triple::thumb:
1139 case llvm::Triple::thumbeb:
1140 case llvm::Triple::x86:
1141 case llvm::Triple::xcore:
1142 case llvm::Triple::amdil:
1143 case llvm::Triple::hsail:
1144 case llvm::Triple::spir:
1145 case llvm::Triple::kalimba:
1146 case llvm::Triple::lanai:
1147 case llvm::Triple::shave:
1148 case llvm::Triple::wasm32:
1149 case llvm::Triple::renderscript32:
1152 case llvm::Triple::aarch64:
1153 case llvm::Triple::aarch64_be:
1154 case llvm::Triple::amdgcn:
1155 case llvm::Triple::bpfel:
1156 case llvm::Triple::bpfeb:
1157 case llvm::Triple::le64:
1158 case llvm::Triple::mips64:
1159 case llvm::Triple::mips64el:
1160 case llvm::Triple::nvptx64:
1161 case llvm::Triple::ppc64:
1162 case llvm::Triple::ppc64le:
1163 case llvm::Triple::sparcv9:
1164 case llvm::Triple::systemz:
1165 case llvm::Triple::x86_64:
1166 case llvm::Triple::amdil64:
1167 case llvm::Triple::hsail64:
1168 case llvm::Triple::spir64:
1169 case llvm::Triple::wasm64:
1170 case llvm::Triple::renderscript64:
1173 llvm_unreachable("Invalid architecture value");
1176 bool Triple::isArch64Bit() const {
1177 return getArchPointerBitWidth(getArch()) == 64;
1180 bool Triple::isArch32Bit() const {
1181 return getArchPointerBitWidth(getArch()) == 32;
1184 bool Triple::isArch16Bit() const {
1185 return getArchPointerBitWidth(getArch()) == 16;
1188 Triple Triple::get32BitArchVariant() const {
1190 switch (getArch()) {
1191 case Triple::UnknownArch:
1192 case Triple::amdgcn:
1196 case Triple::msp430:
1197 case Triple::systemz:
1198 case Triple::ppc64le:
1199 T.setArch(UnknownArch);
1207 case Triple::hexagon:
1208 case Triple::kalimba:
1211 case Triple::mipsel:
1216 case Triple::sparcel:
1219 case Triple::thumbeb:
1224 case Triple::wasm32:
1225 case Triple::renderscript32:
1229 case Triple::aarch64: T.setArch(Triple::arm); break;
1230 case Triple::aarch64_be: T.setArch(Triple::armeb); break;
1231 case Triple::le64: T.setArch(Triple::le32); break;
1232 case Triple::mips64: T.setArch(Triple::mips); break;
1233 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1234 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1235 case Triple::ppc64: T.setArch(Triple::ppc); break;
1236 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1237 case Triple::x86_64: T.setArch(Triple::x86); break;
1238 case Triple::amdil64: T.setArch(Triple::amdil); break;
1239 case Triple::hsail64: T.setArch(Triple::hsail); break;
1240 case Triple::spir64: T.setArch(Triple::spir); break;
1241 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1242 case Triple::renderscript64: T.setArch(Triple::renderscript32); break;
1247 Triple Triple::get64BitArchVariant() const {
1249 switch (getArch()) {
1250 case Triple::UnknownArch:
1252 case Triple::hexagon:
1253 case Triple::kalimba:
1255 case Triple::msp430:
1259 case Triple::sparcel:
1261 T.setArch(UnknownArch);
1264 case Triple::aarch64:
1265 case Triple::aarch64_be:
1269 case Triple::amdil64:
1270 case Triple::amdgcn:
1271 case Triple::hsail64:
1272 case Triple::spir64:
1273 case Triple::mips64:
1274 case Triple::mips64el:
1275 case Triple::nvptx64:
1277 case Triple::ppc64le:
1278 case Triple::sparcv9:
1279 case Triple::systemz:
1280 case Triple::x86_64:
1281 case Triple::wasm64:
1282 case Triple::renderscript64:
1286 case Triple::arm: T.setArch(Triple::aarch64); break;
1287 case Triple::armeb: T.setArch(Triple::aarch64_be); break;
1288 case Triple::le32: T.setArch(Triple::le64); break;
1289 case Triple::mips: T.setArch(Triple::mips64); break;
1290 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1291 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1292 case Triple::ppc: T.setArch(Triple::ppc64); break;
1293 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1294 case Triple::x86: T.setArch(Triple::x86_64); break;
1295 case Triple::amdil: T.setArch(Triple::amdil64); break;
1296 case Triple::hsail: T.setArch(Triple::hsail64); break;
1297 case Triple::spir: T.setArch(Triple::spir64); break;
1298 case Triple::thumb: T.setArch(Triple::aarch64); break;
1299 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break;
1300 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1301 case Triple::renderscript32: T.setArch(Triple::renderscript64); break;
1306 Triple Triple::getBigEndianArchVariant() const {
1308 // Already big endian.
1309 if (!isLittleEndian())
1311 switch (getArch()) {
1312 case Triple::UnknownArch:
1313 case Triple::amdgcn:
1314 case Triple::amdil64:
1317 case Triple::hexagon:
1318 case Triple::hsail64:
1320 case Triple::kalimba:
1323 case Triple::msp430:
1324 case Triple::nvptx64:
1328 case Triple::spir64:
1330 case Triple::wasm32:
1331 case Triple::wasm64:
1333 case Triple::x86_64:
1335 case Triple::renderscript32:
1336 case Triple::renderscript64:
1338 // ARM is intentionally unsupported here, changing the architecture would
1339 // drop any arch suffixes.
1342 T.setArch(UnknownArch);
1345 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1346 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1347 case Triple::mips64el:T.setArch(Triple::mips64); break;
1348 case Triple::mipsel: T.setArch(Triple::mips); break;
1349 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1350 case Triple::sparcel: T.setArch(Triple::sparc); break;
1352 llvm_unreachable("getBigEndianArchVariant: unknown triple.");
1357 Triple Triple::getLittleEndianArchVariant() const {
1359 if (isLittleEndian())
1362 switch (getArch()) {
1363 case Triple::UnknownArch:
1366 case Triple::sparcv9:
1367 case Triple::systemz:
1370 // ARM is intentionally unsupported here, changing the architecture would
1371 // drop any arch suffixes.
1373 case Triple::thumbeb:
1374 T.setArch(UnknownArch);
1377 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1378 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1379 case Triple::mips64: T.setArch(Triple::mips64el); break;
1380 case Triple::mips: T.setArch(Triple::mipsel); break;
1381 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1382 case Triple::sparc: T.setArch(Triple::sparcel); break;
1384 llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
1389 bool Triple::isLittleEndian() const {
1390 switch (getArch()) {
1391 case Triple::aarch64:
1392 case Triple::amdgcn:
1393 case Triple::amdil64:
1398 case Triple::hexagon:
1399 case Triple::hsail64:
1401 case Triple::kalimba:
1404 case Triple::mips64el:
1405 case Triple::mipsel:
1406 case Triple::msp430:
1407 case Triple::nvptx64:
1409 case Triple::ppc64le:
1412 case Triple::sparcel:
1413 case Triple::spir64:
1416 case Triple::wasm32:
1417 case Triple::wasm64:
1419 case Triple::x86_64:
1421 case Triple::renderscript32:
1422 case Triple::renderscript64:
1429 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1431 MArch = getArchName();
1432 MArch = ARM::getCanonicalArchName(MArch);
1434 // Some defaults are forced.
1436 case llvm::Triple::FreeBSD:
1437 case llvm::Triple::NetBSD:
1438 if (!MArch.empty() && MArch == "v6")
1439 return "arm1176jzf-s";
1441 case llvm::Triple::Win32:
1442 // FIXME: this is invalid for WindowsCE
1444 case llvm::Triple::MacOSX:
1445 case llvm::Triple::IOS:
1446 case llvm::Triple::WatchOS:
1447 case llvm::Triple::TvOS:
1458 StringRef CPU = ARM::getDefaultCPU(MArch);
1462 // If no specific architecture version is requested, return the minimum CPU
1463 // required by the OS and environment.
1465 case llvm::Triple::NetBSD:
1466 switch (getEnvironment()) {
1467 case llvm::Triple::GNUEABIHF:
1468 case llvm::Triple::GNUEABI:
1469 case llvm::Triple::EABIHF:
1470 case llvm::Triple::EABI:
1471 return "arm926ej-s";
1475 case llvm::Triple::NaCl:
1478 switch (getEnvironment()) {
1479 case llvm::Triple::EABIHF:
1480 case llvm::Triple::GNUEABIHF:
1481 case llvm::Triple::MuslEABIHF:
1482 return "arm1176jzf-s";
1488 llvm_unreachable("invalid arch name");