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 bpf: return "bpf";
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 amdgcn: return "amdgcn";
38 case sparc: return "sparc";
39 case sparcv9: return "sparcv9";
40 case sparcel: return "sparcel";
41 case systemz: return "s390x";
42 case tce: return "tce";
43 case thumb: return "thumb";
44 case thumbeb: return "thumbeb";
45 case x86: return "i386";
46 case x86_64: return "x86_64";
47 case xcore: return "xcore";
48 case nvptx: return "nvptx";
49 case nvptx64: return "nvptx64";
50 case le32: return "le32";
51 case le64: return "le64";
52 case amdil: return "amdil";
53 case amdil64: return "amdil64";
54 case hsail: return "hsail";
55 case hsail64: return "hsail64";
56 case spir: return "spir";
57 case spir64: return "spir64";
58 case kalimba: return "kalimba";
61 llvm_unreachable("Invalid ArchType!");
64 const char *Triple::getArchTypePrefix(ArchType Kind) {
70 case aarch64_be: return "aarch64";
75 case thumbeb: return "arm";
79 case ppc: return "ppc";
84 case mips64el: return "mips";
86 case hexagon: return "hexagon";
89 case r600: return "amdgpu";
91 case bpf: return "bpf";
95 case sparc: return "sparc";
97 case systemz: return "s390";
100 case x86_64: return "x86";
102 case xcore: return "xcore";
104 case nvptx: return "nvptx";
105 case nvptx64: return "nvptx";
107 case le32: return "le32";
108 case le64: return "le64";
111 case amdil64: return "amdil";
114 case hsail64: return "hsail";
117 case spir64: return "spir";
118 case kalimba: return "kalimba";
122 const char *Triple::getVendorTypeName(VendorType Kind) {
124 case UnknownVendor: return "unknown";
126 case Apple: return "apple";
127 case PC: return "pc";
128 case SCEI: return "scei";
129 case BGP: return "bgp";
130 case BGQ: return "bgq";
131 case Freescale: return "fsl";
132 case IBM: return "ibm";
133 case ImaginationTechnologies: return "img";
134 case MipsTechnologies: return "mti";
135 case NVIDIA: return "nvidia";
136 case CSR: return "csr";
139 llvm_unreachable("Invalid VendorType!");
142 const char *Triple::getOSTypeName(OSType Kind) {
144 case UnknownOS: return "unknown";
146 case CloudABI: return "cloudabi";
147 case Darwin: return "darwin";
148 case DragonFly: return "dragonfly";
149 case FreeBSD: return "freebsd";
150 case IOS: return "ios";
151 case KFreeBSD: return "kfreebsd";
152 case Linux: return "linux";
153 case Lv2: return "lv2";
154 case MacOSX: return "macosx";
155 case NetBSD: return "netbsd";
156 case OpenBSD: return "openbsd";
157 case Solaris: return "solaris";
158 case Win32: return "windows";
159 case Haiku: return "haiku";
160 case Minix: return "minix";
161 case RTEMS: return "rtems";
162 case NaCl: return "nacl";
163 case CNK: return "cnk";
164 case Bitrig: return "bitrig";
165 case AIX: return "aix";
166 case CUDA: return "cuda";
167 case NVCL: return "nvcl";
168 case AMDHSA: return "amdhsa";
169 case PS4: return "ps4";
172 llvm_unreachable("Invalid OSType");
175 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
177 case UnknownEnvironment: return "unknown";
178 case GNU: return "gnu";
179 case GNUEABIHF: return "gnueabihf";
180 case GNUEABI: return "gnueabi";
181 case GNUX32: return "gnux32";
182 case CODE16: return "code16";
183 case EABI: return "eabi";
184 case EABIHF: return "eabihf";
185 case Android: return "android";
186 case MSVC: return "msvc";
187 case Itanium: return "itanium";
188 case Cygnus: return "cygnus";
191 llvm_unreachable("Invalid EnvironmentType!");
194 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
195 return StringSwitch<Triple::ArchType>(Name)
196 .Case("aarch64", aarch64)
197 .Case("aarch64_be", aarch64_be)
198 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
200 .Case("armeb", armeb)
203 .Case("mipsel", mipsel)
204 .Case("mips64", mips64)
205 .Case("mips64el", mips64el)
206 .Case("msp430", msp430)
207 .Case("ppc64", ppc64)
210 .Case("ppc64le", ppc64le)
212 .Case("amdgcn", amdgcn)
213 .Case("hexagon", hexagon)
214 .Case("sparc", sparc)
215 .Case("sparcel", sparcel)
216 .Case("sparcv9", sparcv9)
217 .Case("systemz", systemz)
219 .Case("thumb", thumb)
220 .Case("thumbeb", thumbeb)
222 .Case("x86-64", x86_64)
223 .Case("xcore", xcore)
224 .Case("nvptx", nvptx)
225 .Case("nvptx64", nvptx64)
228 .Case("amdil", amdil)
229 .Case("amdil64", amdil64)
230 .Case("hsail", hsail)
231 .Case("hsail64", hsail64)
233 .Case("spir64", spir64)
234 .Case("kalimba", kalimba)
235 .Default(UnknownArch);
238 static Triple::ArchType parseARMArch(StringRef ArchName) {
239 size_t offset = StringRef::npos;
240 Triple::ArchType arch = Triple::UnknownArch;
241 bool isThumb = ArchName.startswith("thumb");
243 if (ArchName.equals("arm"))
245 if (ArchName.equals("armeb"))
246 return Triple::armeb;
247 if (ArchName.equals("thumb"))
248 return Triple::thumb;
249 if (ArchName.equals("thumbeb"))
250 return Triple::thumbeb;
251 if (ArchName.equals("arm64") || ArchName.equals("aarch64"))
252 return Triple::aarch64;
253 if (ArchName.equals("aarch64_be"))
254 return Triple::aarch64_be;
256 if (ArchName.startswith("armv")) {
258 if (ArchName.endswith("eb")) {
259 arch = Triple::armeb;
260 ArchName = ArchName.substr(0, ArchName.size() - 2);
263 } else if (ArchName.startswith("armebv")) {
265 arch = Triple::armeb;
266 } else if (ArchName.startswith("thumbv")) {
268 if (ArchName.endswith("eb")) {
269 arch = Triple::thumbeb;
270 ArchName = ArchName.substr(0, ArchName.size() - 2);
272 arch = Triple::thumb;
273 } else if (ArchName.startswith("thumbebv")) {
275 arch = Triple::thumbeb;
277 return StringSwitch<Triple::ArchType>(ArchName.substr(offset))
278 .Cases("v2", "v2a", isThumb ? Triple::UnknownArch : arch)
279 .Cases("v3", "v3m", isThumb ? Triple::UnknownArch : arch)
280 .Cases("v4", "v4t", arch)
281 .Cases("v5", "v5e", "v5t", "v5te", "v5tej", arch)
282 .Cases("v6", "v6hl", "v6j", "v6k", arch)
283 .Cases("v6m", "v6sm", arch)
284 .Cases("v6t2", "v6z", "v6zk", arch)
285 .Cases("v7", "v7a", "v7em", "v7hl", "v7l", arch)
286 .Cases("v7m", "v7r", "v7s", arch)
287 .Cases("v8", "v8a", arch)
288 .Cases("v8.1", "v8.1a", arch)
289 .Default(Triple::UnknownArch);
292 static Triple::ArchType parseArch(StringRef ArchName) {
293 Triple::ArchType ARMArch(parseARMArch(ArchName));
295 return StringSwitch<Triple::ArchType>(ArchName)
296 .Cases("i386", "i486", "i586", "i686", Triple::x86)
297 // FIXME: Do we need to support these?
298 .Cases("i786", "i886", "i986", Triple::x86)
299 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
300 .Case("powerpc", Triple::ppc)
301 .Cases("powerpc64", "ppu", Triple::ppc64)
302 .Case("powerpc64le", Triple::ppc64le)
303 .Case("xscale", Triple::arm)
304 .Case("xscaleeb", Triple::armeb)
305 .StartsWith("arm", ARMArch)
306 .StartsWith("thumb", ARMArch)
307 .StartsWith("aarch64", ARMArch)
308 .Case("msp430", Triple::msp430)
309 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
310 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
311 .Cases("mips64", "mips64eb", Triple::mips64)
312 .Case("mips64el", Triple::mips64el)
313 .Case("r600", Triple::r600)
314 .Case("amdgcn", Triple::amdgcn)
315 .Case("bpf", Triple::bpf)
316 .Case("hexagon", Triple::hexagon)
317 .Case("s390x", Triple::systemz)
318 .Case("sparc", Triple::sparc)
319 .Case("sparcel", Triple::sparcel)
320 .Cases("sparcv9", "sparc64", Triple::sparcv9)
321 .Case("tce", Triple::tce)
322 .Case("xcore", Triple::xcore)
323 .Case("nvptx", Triple::nvptx)
324 .Case("nvptx64", Triple::nvptx64)
325 .Case("le32", Triple::le32)
326 .Case("le64", Triple::le64)
327 .Case("amdil", Triple::amdil)
328 .Case("amdil64", Triple::amdil64)
329 .Case("hsail", Triple::hsail)
330 .Case("hsail64", Triple::hsail64)
331 .Case("spir", Triple::spir)
332 .Case("spir64", Triple::spir64)
333 .StartsWith("kalimba", Triple::kalimba)
334 .Default(Triple::UnknownArch);
337 static Triple::VendorType parseVendor(StringRef VendorName) {
338 return StringSwitch<Triple::VendorType>(VendorName)
339 .Case("apple", Triple::Apple)
340 .Case("pc", Triple::PC)
341 .Case("scei", Triple::SCEI)
342 .Case("bgp", Triple::BGP)
343 .Case("bgq", Triple::BGQ)
344 .Case("fsl", Triple::Freescale)
345 .Case("ibm", Triple::IBM)
346 .Case("img", Triple::ImaginationTechnologies)
347 .Case("mti", Triple::MipsTechnologies)
348 .Case("nvidia", Triple::NVIDIA)
349 .Case("csr", Triple::CSR)
350 .Default(Triple::UnknownVendor);
353 static Triple::OSType parseOS(StringRef OSName) {
354 return StringSwitch<Triple::OSType>(OSName)
355 .StartsWith("cloudabi", Triple::CloudABI)
356 .StartsWith("darwin", Triple::Darwin)
357 .StartsWith("dragonfly", Triple::DragonFly)
358 .StartsWith("freebsd", Triple::FreeBSD)
359 .StartsWith("ios", Triple::IOS)
360 .StartsWith("kfreebsd", Triple::KFreeBSD)
361 .StartsWith("linux", Triple::Linux)
362 .StartsWith("lv2", Triple::Lv2)
363 .StartsWith("macosx", Triple::MacOSX)
364 .StartsWith("netbsd", Triple::NetBSD)
365 .StartsWith("openbsd", Triple::OpenBSD)
366 .StartsWith("solaris", Triple::Solaris)
367 .StartsWith("win32", Triple::Win32)
368 .StartsWith("windows", Triple::Win32)
369 .StartsWith("haiku", Triple::Haiku)
370 .StartsWith("minix", Triple::Minix)
371 .StartsWith("rtems", Triple::RTEMS)
372 .StartsWith("nacl", Triple::NaCl)
373 .StartsWith("cnk", Triple::CNK)
374 .StartsWith("bitrig", Triple::Bitrig)
375 .StartsWith("aix", Triple::AIX)
376 .StartsWith("cuda", Triple::CUDA)
377 .StartsWith("nvcl", Triple::NVCL)
378 .StartsWith("amdhsa", Triple::AMDHSA)
379 .StartsWith("ps4", Triple::PS4)
380 .Default(Triple::UnknownOS);
383 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
384 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
385 .StartsWith("eabihf", Triple::EABIHF)
386 .StartsWith("eabi", Triple::EABI)
387 .StartsWith("gnueabihf", Triple::GNUEABIHF)
388 .StartsWith("gnueabi", Triple::GNUEABI)
389 .StartsWith("gnux32", Triple::GNUX32)
390 .StartsWith("code16", Triple::CODE16)
391 .StartsWith("gnu", Triple::GNU)
392 .StartsWith("android", Triple::Android)
393 .StartsWith("msvc", Triple::MSVC)
394 .StartsWith("itanium", Triple::Itanium)
395 .StartsWith("cygnus", Triple::Cygnus)
396 .Default(Triple::UnknownEnvironment);
399 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
400 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
401 .EndsWith("coff", Triple::COFF)
402 .EndsWith("elf", Triple::ELF)
403 .EndsWith("macho", Triple::MachO)
404 .Default(Triple::UnknownObjectFormat);
407 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
408 if (SubArchName.endswith("eb"))
409 SubArchName = SubArchName.substr(0, SubArchName.size() - 2);
411 return StringSwitch<Triple::SubArchType>(SubArchName)
412 .EndsWith("v8.1a", Triple::ARMSubArch_v8_1a)
413 .EndsWith("v8", Triple::ARMSubArch_v8)
414 .EndsWith("v8a", Triple::ARMSubArch_v8)
415 .EndsWith("v7", Triple::ARMSubArch_v7)
416 .EndsWith("v7a", Triple::ARMSubArch_v7)
417 .EndsWith("v7em", Triple::ARMSubArch_v7em)
418 .EndsWith("v7l", Triple::ARMSubArch_v7)
419 .EndsWith("v7m", Triple::ARMSubArch_v7m)
420 .EndsWith("v7r", Triple::ARMSubArch_v7)
421 .EndsWith("v7s", Triple::ARMSubArch_v7s)
422 .EndsWith("v6", Triple::ARMSubArch_v6)
423 .EndsWith("v6m", Triple::ARMSubArch_v6m)
424 .EndsWith("v6sm", Triple::ARMSubArch_v6m)
425 .EndsWith("v6k", Triple::ARMSubArch_v6k)
426 .EndsWith("v6t2", Triple::ARMSubArch_v6t2)
427 .EndsWith("v5", Triple::ARMSubArch_v5)
428 .EndsWith("v5e", Triple::ARMSubArch_v5)
429 .EndsWith("v5t", Triple::ARMSubArch_v5)
430 .EndsWith("v5te", Triple::ARMSubArch_v5te)
431 .EndsWith("v4t", Triple::ARMSubArch_v4t)
432 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
433 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
434 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
435 .Default(Triple::NoSubArch);
438 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
440 case Triple::UnknownObjectFormat: return "";
441 case Triple::COFF: return "coff";
442 case Triple::ELF: return "elf";
443 case Triple::MachO: return "macho";
445 llvm_unreachable("unknown object format type");
448 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
449 switch (T.getArch()) {
452 case Triple::hexagon:
456 case Triple::mips64el:
460 case Triple::sparcv9:
461 case Triple::systemz:
463 case Triple::ppc64le:
469 return Triple::MachO;
474 return Triple::MachO;
475 else if (T.isOSWindows())
480 /// \brief Construct a triple from the string representation provided.
482 /// This stores the string representation and parses the various pieces into
484 Triple::Triple(const Twine &Str)
486 Arch(parseArch(getArchName())),
487 SubArch(parseSubArch(getArchName())),
488 Vendor(parseVendor(getVendorName())),
489 OS(parseOS(getOSName())),
490 Environment(parseEnvironment(getEnvironmentName())),
491 ObjectFormat(parseFormat(getEnvironmentName())) {
492 if (ObjectFormat == Triple::UnknownObjectFormat)
493 ObjectFormat = getDefaultFormat(*this);
496 /// \brief Construct a triple from string representations of the architecture,
499 /// This joins each argument into a canonical string representation and parses
500 /// them into enum members. It leaves the environment unknown and omits it from
501 /// the string representation.
502 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
503 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
504 Arch(parseArch(ArchStr.str())),
505 SubArch(parseSubArch(ArchStr.str())),
506 Vendor(parseVendor(VendorStr.str())),
507 OS(parseOS(OSStr.str())),
508 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
509 ObjectFormat = getDefaultFormat(*this);
512 /// \brief Construct a triple from string representations of the architecture,
513 /// vendor, OS, and environment.
515 /// This joins each argument into a canonical string representation and parses
516 /// them into enum members.
517 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
518 const Twine &EnvironmentStr)
519 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
520 EnvironmentStr).str()),
521 Arch(parseArch(ArchStr.str())),
522 SubArch(parseSubArch(ArchStr.str())),
523 Vendor(parseVendor(VendorStr.str())),
524 OS(parseOS(OSStr.str())),
525 Environment(parseEnvironment(EnvironmentStr.str())),
526 ObjectFormat(parseFormat(EnvironmentStr.str())) {
527 if (ObjectFormat == Triple::UnknownObjectFormat)
528 ObjectFormat = getDefaultFormat(*this);
531 std::string Triple::normalize(StringRef Str) {
532 bool IsMinGW32 = false;
533 bool IsCygwin = false;
535 // Parse into components.
536 SmallVector<StringRef, 4> Components;
537 Str.split(Components, "-");
539 // If the first component corresponds to a known architecture, preferentially
540 // use it for the architecture. If the second component corresponds to a
541 // known vendor, preferentially use it for the vendor, etc. This avoids silly
542 // component movement when a component parses as (eg) both a valid arch and a
544 ArchType Arch = UnknownArch;
545 if (Components.size() > 0)
546 Arch = parseArch(Components[0]);
547 VendorType Vendor = UnknownVendor;
548 if (Components.size() > 1)
549 Vendor = parseVendor(Components[1]);
550 OSType OS = UnknownOS;
551 if (Components.size() > 2) {
552 OS = parseOS(Components[2]);
553 IsCygwin = Components[2].startswith("cygwin");
554 IsMinGW32 = Components[2].startswith("mingw");
556 EnvironmentType Environment = UnknownEnvironment;
557 if (Components.size() > 3)
558 Environment = parseEnvironment(Components[3]);
559 ObjectFormatType ObjectFormat = UnknownObjectFormat;
560 if (Components.size() > 4)
561 ObjectFormat = parseFormat(Components[4]);
563 // Note which components are already in their final position. These will not
566 Found[0] = Arch != UnknownArch;
567 Found[1] = Vendor != UnknownVendor;
568 Found[2] = OS != UnknownOS;
569 Found[3] = Environment != UnknownEnvironment;
571 // If they are not there already, permute the components into their canonical
572 // positions by seeing if they parse as a valid architecture, and if so moving
573 // the component to the architecture position etc.
574 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
576 continue; // Already in the canonical position.
578 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
579 // Do not reparse any components that already matched.
580 if (Idx < array_lengthof(Found) && Found[Idx])
583 // Does this component parse as valid for the target position?
585 StringRef Comp = Components[Idx];
587 default: llvm_unreachable("unexpected component type!");
589 Arch = parseArch(Comp);
590 Valid = Arch != UnknownArch;
593 Vendor = parseVendor(Comp);
594 Valid = Vendor != UnknownVendor;
598 IsCygwin = Comp.startswith("cygwin");
599 IsMinGW32 = Comp.startswith("mingw");
600 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
603 Environment = parseEnvironment(Comp);
604 Valid = Environment != UnknownEnvironment;
606 ObjectFormat = parseFormat(Comp);
607 Valid = ObjectFormat != UnknownObjectFormat;
612 continue; // Nope, try the next component.
614 // Move the component to the target position, pushing any non-fixed
615 // components that are in the way to the right. This tends to give
616 // good results in the common cases of a forgotten vendor component
617 // or a wrongly positioned environment.
619 // Insert left, pushing the existing components to the right. For
620 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
621 StringRef CurrentComponent(""); // The empty component.
622 // Replace the component we are moving with an empty component.
623 std::swap(CurrentComponent, Components[Idx]);
624 // Insert the component being moved at Pos, displacing any existing
625 // components to the right.
626 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
627 // Skip over any fixed components.
628 while (i < array_lengthof(Found) && Found[i])
630 // Place the component at the new position, getting the component
631 // that was at this position - it will be moved right.
632 std::swap(CurrentComponent, Components[i]);
634 } else if (Pos > Idx) {
635 // Push right by inserting empty components until the component at Idx
636 // reaches the target position Pos. For example, pc-a -> -pc-a when
637 // moving pc to the second position.
639 // Insert one empty component at Idx.
640 StringRef CurrentComponent(""); // The empty component.
641 for (unsigned i = Idx; i < Components.size();) {
642 // Place the component at the new position, getting the component
643 // that was at this position - it will be moved right.
644 std::swap(CurrentComponent, Components[i]);
645 // If it was placed on top of an empty component then we are done.
646 if (CurrentComponent.empty())
648 // Advance to the next component, skipping any fixed components.
649 while (++i < array_lengthof(Found) && Found[i])
652 // The last component was pushed off the end - append it.
653 if (!CurrentComponent.empty())
654 Components.push_back(CurrentComponent);
656 // Advance Idx to the component's new position.
657 while (++Idx < array_lengthof(Found) && Found[Idx])
659 } while (Idx < Pos); // Add more until the final position is reached.
661 assert(Pos < Components.size() && Components[Pos] == Comp &&
662 "Component moved wrong!");
668 // Special case logic goes here. At this point Arch, Vendor and OS have the
669 // correct values for the computed components.
671 if (OS == Triple::Win32) {
672 Components.resize(4);
673 Components[2] = "windows";
674 if (Environment == UnknownEnvironment) {
675 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
676 Components[3] = "msvc";
678 Components[3] = getObjectFormatTypeName(ObjectFormat);
680 } else if (IsMinGW32) {
681 Components.resize(4);
682 Components[2] = "windows";
683 Components[3] = "gnu";
684 } else if (IsCygwin) {
685 Components.resize(4);
686 Components[2] = "windows";
687 Components[3] = "cygnus";
689 if (IsMinGW32 || IsCygwin ||
690 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
691 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
692 Components.resize(5);
693 Components[4] = getObjectFormatTypeName(ObjectFormat);
697 // Stick the corrected components back together to form the normalized string.
698 std::string Normalized;
699 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
700 if (i) Normalized += '-';
701 Normalized += Components[i];
706 StringRef Triple::getArchName() const {
707 return StringRef(Data).split('-').first; // Isolate first component
710 StringRef Triple::getVendorName() const {
711 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
712 return Tmp.split('-').first; // Isolate second component
715 StringRef Triple::getOSName() const {
716 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
717 Tmp = Tmp.split('-').second; // Strip second component
718 return Tmp.split('-').first; // Isolate third component
721 StringRef Triple::getEnvironmentName() const {
722 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
723 Tmp = Tmp.split('-').second; // Strip second component
724 return Tmp.split('-').second; // Strip third component
727 StringRef Triple::getOSAndEnvironmentName() const {
728 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
729 return Tmp.split('-').second; // Strip second component
732 static unsigned EatNumber(StringRef &Str) {
733 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
737 // Consume the leading digit.
738 Result = Result*10 + (Str[0] - '0');
742 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
747 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
748 unsigned &Micro) const {
749 StringRef OSName = getOSName();
751 // For Android, we care about the Android version rather than the Linux
753 if (getEnvironment() == Android) {
754 OSName = getEnvironmentName().substr(strlen("android"));
755 if (OSName.startswith("eabi"))
756 OSName = OSName.substr(strlen("eabi"));
759 // Assume that the OS portion of the triple starts with the canonical name.
760 StringRef OSTypeName = getOSTypeName(getOS());
761 if (OSName.startswith(OSTypeName))
762 OSName = OSName.substr(OSTypeName.size());
764 // Any unset version defaults to 0.
765 Major = Minor = Micro = 0;
767 // Parse up to three components.
768 unsigned *Components[3] = { &Major, &Minor, &Micro };
769 for (unsigned i = 0; i != 3; ++i) {
770 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
773 // Consume the leading number.
774 *Components[i] = EatNumber(OSName);
776 // Consume the separator, if present.
777 if (OSName.startswith("."))
778 OSName = OSName.substr(1);
782 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
783 unsigned &Micro) const {
784 getOSVersion(Major, Minor, Micro);
787 default: llvm_unreachable("unexpected OS for Darwin triple");
789 // Default to darwin8, i.e., MacOSX 10.4.
792 // Darwin version numbers are skewed from OS X versions.
809 // Ignore the version from the triple. This is only handled because the
810 // the clang driver combines OS X and IOS support into a common Darwin
811 // toolchain that wants to know the OS X version number even when targeting
821 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
822 unsigned &Micro) const {
824 default: llvm_unreachable("unexpected OS for Darwin triple");
827 // Ignore the version from the triple. This is only handled because the
828 // the clang driver combines OS X and IOS support into a common Darwin
829 // toolchain that wants to know the iOS version number even when targeting
836 getOSVersion(Major, Minor, Micro);
837 // Default to 5.0 (or 7.0 for arm64).
839 Major = (getArch() == aarch64) ? 7 : 5;
844 void Triple::setTriple(const Twine &Str) {
848 void Triple::setArch(ArchType Kind) {
849 setArchName(getArchTypeName(Kind));
852 void Triple::setVendor(VendorType Kind) {
853 setVendorName(getVendorTypeName(Kind));
856 void Triple::setOS(OSType Kind) {
857 setOSName(getOSTypeName(Kind));
860 void Triple::setEnvironment(EnvironmentType Kind) {
861 if (ObjectFormat == getDefaultFormat(*this))
862 return setEnvironmentName(getEnvironmentTypeName(Kind));
864 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
865 getObjectFormatTypeName(ObjectFormat)).str());
868 void Triple::setObjectFormat(ObjectFormatType Kind) {
869 if (Environment == UnknownEnvironment)
870 return setEnvironmentName(getObjectFormatTypeName(Kind));
872 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
873 getObjectFormatTypeName(Kind)).str());
876 void Triple::setArchName(StringRef Str) {
877 // Work around a miscompilation bug for Twines in gcc 4.0.3.
878 SmallString<64> Triple;
881 Triple += getVendorName();
883 Triple += getOSAndEnvironmentName();
887 void Triple::setVendorName(StringRef Str) {
888 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
891 void Triple::setOSName(StringRef Str) {
892 if (hasEnvironment())
893 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
894 "-" + getEnvironmentName());
896 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
899 void Triple::setEnvironmentName(StringRef Str) {
900 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
904 void Triple::setOSAndEnvironmentName(StringRef Str) {
905 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
908 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
910 case llvm::Triple::UnknownArch:
913 case llvm::Triple::msp430:
916 case llvm::Triple::arm:
917 case llvm::Triple::armeb:
918 case llvm::Triple::hexagon:
919 case llvm::Triple::le32:
920 case llvm::Triple::mips:
921 case llvm::Triple::mipsel:
922 case llvm::Triple::nvptx:
923 case llvm::Triple::ppc:
924 case llvm::Triple::r600:
925 case llvm::Triple::sparc:
926 case llvm::Triple::sparcel:
927 case llvm::Triple::tce:
928 case llvm::Triple::thumb:
929 case llvm::Triple::thumbeb:
930 case llvm::Triple::x86:
931 case llvm::Triple::xcore:
932 case llvm::Triple::amdil:
933 case llvm::Triple::hsail:
934 case llvm::Triple::spir:
935 case llvm::Triple::kalimba:
938 case llvm::Triple::aarch64:
939 case llvm::Triple::aarch64_be:
940 case llvm::Triple::amdgcn:
941 case llvm::Triple::bpf:
942 case llvm::Triple::le64:
943 case llvm::Triple::mips64:
944 case llvm::Triple::mips64el:
945 case llvm::Triple::nvptx64:
946 case llvm::Triple::ppc64:
947 case llvm::Triple::ppc64le:
948 case llvm::Triple::sparcv9:
949 case llvm::Triple::systemz:
950 case llvm::Triple::x86_64:
951 case llvm::Triple::amdil64:
952 case llvm::Triple::hsail64:
953 case llvm::Triple::spir64:
956 llvm_unreachable("Invalid architecture value");
959 bool Triple::isArch64Bit() const {
960 return getArchPointerBitWidth(getArch()) == 64;
963 bool Triple::isArch32Bit() const {
964 return getArchPointerBitWidth(getArch()) == 32;
967 bool Triple::isArch16Bit() const {
968 return getArchPointerBitWidth(getArch()) == 16;
971 Triple Triple::get32BitArchVariant() const {
974 case Triple::UnknownArch:
975 case Triple::aarch64:
976 case Triple::aarch64_be:
980 case Triple::systemz:
981 case Triple::ppc64le:
982 T.setArch(UnknownArch);
990 case Triple::hexagon:
991 case Triple::kalimba:
999 case Triple::sparcel:
1002 case Triple::thumbeb:
1008 case Triple::le64: T.setArch(Triple::le32); break;
1009 case Triple::mips64: T.setArch(Triple::mips); break;
1010 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1011 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1012 case Triple::ppc64: T.setArch(Triple::ppc); break;
1013 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1014 case Triple::x86_64: T.setArch(Triple::x86); break;
1015 case Triple::amdil64: T.setArch(Triple::amdil); break;
1016 case Triple::hsail64: T.setArch(Triple::hsail); break;
1017 case Triple::spir64: T.setArch(Triple::spir); break;
1022 Triple Triple::get64BitArchVariant() const {
1024 switch (getArch()) {
1025 case Triple::UnknownArch:
1028 case Triple::hexagon:
1029 case Triple::kalimba:
1030 case Triple::msp430:
1034 case Triple::thumbeb:
1036 case Triple::sparcel:
1037 T.setArch(UnknownArch);
1040 case Triple::aarch64:
1041 case Triple::aarch64_be:
1044 case Triple::amdil64:
1045 case Triple::amdgcn:
1046 case Triple::hsail64:
1047 case Triple::spir64:
1048 case Triple::mips64:
1049 case Triple::mips64el:
1050 case Triple::nvptx64:
1052 case Triple::ppc64le:
1053 case Triple::sparcv9:
1054 case Triple::systemz:
1055 case Triple::x86_64:
1059 case Triple::le32: T.setArch(Triple::le64); break;
1060 case Triple::mips: T.setArch(Triple::mips64); break;
1061 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1062 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1063 case Triple::ppc: T.setArch(Triple::ppc64); break;
1064 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1065 case Triple::x86: T.setArch(Triple::x86_64); break;
1066 case Triple::amdil: T.setArch(Triple::amdil64); break;
1067 case Triple::hsail: T.setArch(Triple::hsail64); break;
1068 case Triple::spir: T.setArch(Triple::spir64); break;
1073 // FIXME: tblgen this.
1074 const char *Triple::getARMCPUForArch(StringRef MArch) const {
1076 MArch = getArchName();
1079 case llvm::Triple::FreeBSD:
1080 case llvm::Triple::NetBSD:
1081 if (MArch == "armv6")
1082 return "arm1176jzf-s";
1084 case llvm::Triple::Win32:
1085 // FIXME: this is invalid for WindowsCE
1091 const char *result = nullptr;
1092 size_t offset = StringRef::npos;
1093 if (MArch.startswith("arm"))
1095 if (MArch.startswith("thumb"))
1097 if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
1099 if (MArch.endswith("eb"))
1100 MArch = MArch.substr(0, MArch.size() - 2);
1101 if (offset != StringRef::npos)
1102 result = llvm::StringSwitch<const char *>(MArch.substr(offset))
1103 .Cases("v2", "v2a", "arm2")
1105 .Case("v3m", "arm7m")
1106 .Case("v4", "strongarm")
1107 .Case("v4t", "arm7tdmi")
1108 .Cases("v5", "v5t", "arm10tdmi")
1109 .Cases("v5e", "v5te", "arm1022e")
1110 .Case("v5tej", "arm926ej-s")
1111 .Case("v6", "arm1136jf-s")
1112 .Case("v6j", "arm1136j-s")
1113 .Cases("v6k", "v6z", "v6zk", "arm1176jzf-s")
1114 .Case("v6t2", "arm1156t2-s")
1115 .Cases("v6m", "v6-m", "v6sm", "v6s-m", "cortex-m0")
1116 .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
1117 .Cases("v7s", "v7-s", "swift")
1118 .Cases("v7r", "v7-r", "cortex-r4")
1119 .Cases("v7m", "v7-m", "cortex-m3")
1120 .Cases("v7em", "v7e-m", "cortex-m4")
1121 .Cases("v8", "v8a", "v8-a", "cortex-a53")
1122 .Cases("v8.1a", "v8.1-a", "generic")
1125 result = llvm::StringSwitch<const char *>(MArch)
1126 .Case("ep9312", "ep9312")
1127 .Case("iwmmxt", "iwmmxt")
1128 .Case("xscale", "xscale")
1134 // If all else failed, return the most base CPU with thumb interworking
1135 // supported by LLVM.
1136 // FIXME: Should warn once that we're falling back.
1138 case llvm::Triple::NetBSD:
1139 switch (getEnvironment()) {
1140 case llvm::Triple::GNUEABIHF:
1141 case llvm::Triple::GNUEABI:
1142 case llvm::Triple::EABIHF:
1143 case llvm::Triple::EABI:
1144 return "arm926ej-s";
1148 case llvm::Triple::NaCl:
1151 switch (getEnvironment()) {
1152 case llvm::Triple::EABIHF:
1153 case llvm::Triple::GNUEABIHF:
1154 return "arm1176jzf-s";