Handle ARMv6KZ naming
[oota-llvm.git] / lib / Support / Triple.cpp
1 //===--- Triple.cpp - Target triple helper class --------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
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"
17 #include <cstring>
18 using namespace llvm;
19
20 const char *Triple::getArchTypeName(ArchType Kind) {
21   switch (Kind) {
22   case UnknownArch: return "unknown";
23
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 shave:       return "shave";
64   case wasm32:      return "wasm32";
65   case wasm64:      return "wasm64";
66   }
67
68   llvm_unreachable("Invalid ArchType!");
69 }
70
71 const char *Triple::getArchTypePrefix(ArchType Kind) {
72   switch (Kind) {
73   default:
74     return nullptr;
75
76   case aarch64:
77   case aarch64_be:  return "aarch64";
78
79   case arm:
80   case armeb:
81   case thumb:
82   case thumbeb:     return "arm";
83
84   case avr:         return "avr";
85
86   case ppc64:
87   case ppc64le:
88   case ppc:         return "ppc";
89
90   case mips:
91   case mipsel:
92   case mips64:
93   case mips64el:    return "mips";
94
95   case hexagon:     return "hexagon";
96
97   case amdgcn:
98   case r600:        return "amdgpu";
99
100   case bpfel:
101   case bpfeb:       return "bpf";
102
103   case sparcv9:
104   case sparcel:
105   case sparc:       return "sparc";
106
107   case systemz:     return "s390";
108
109   case x86:
110   case x86_64:      return "x86";
111
112   case xcore:       return "xcore";
113
114   case nvptx:       return "nvptx";
115   case nvptx64:     return "nvptx";
116
117   case le32:        return "le32";
118   case le64:        return "le64";
119
120   case amdil:
121   case amdil64:     return "amdil";
122
123   case hsail:
124   case hsail64:     return "hsail";
125
126   case spir:
127   case spir64:      return "spir";
128   case kalimba:     return "kalimba";
129   case shave:       return "shave";
130   case wasm32:
131   case wasm64:      return "wasm";
132   }
133 }
134
135 const char *Triple::getVendorTypeName(VendorType Kind) {
136   switch (Kind) {
137   case UnknownVendor: return "unknown";
138
139   case Apple: return "apple";
140   case PC: return "pc";
141   case SCEI: return "scei";
142   case BGP: return "bgp";
143   case BGQ: return "bgq";
144   case Freescale: return "fsl";
145   case IBM: return "ibm";
146   case ImaginationTechnologies: return "img";
147   case MipsTechnologies: return "mti";
148   case NVIDIA: return "nvidia";
149   case CSR: return "csr";
150   case Myriad: return "myriad";
151   }
152
153   llvm_unreachable("Invalid VendorType!");
154 }
155
156 const char *Triple::getOSTypeName(OSType Kind) {
157   switch (Kind) {
158   case UnknownOS: return "unknown";
159
160   case CloudABI: return "cloudabi";
161   case Darwin: return "darwin";
162   case DragonFly: return "dragonfly";
163   case FreeBSD: return "freebsd";
164   case IOS: return "ios";
165   case KFreeBSD: return "kfreebsd";
166   case Linux: return "linux";
167   case Lv2: return "lv2";
168   case MacOSX: return "macosx";
169   case NetBSD: return "netbsd";
170   case OpenBSD: return "openbsd";
171   case Solaris: return "solaris";
172   case Win32: return "windows";
173   case Haiku: return "haiku";
174   case Minix: return "minix";
175   case RTEMS: return "rtems";
176   case NaCl: return "nacl";
177   case CNK: return "cnk";
178   case Bitrig: return "bitrig";
179   case AIX: return "aix";
180   case CUDA: return "cuda";
181   case NVCL: return "nvcl";
182   case AMDHSA: return "amdhsa";
183   case PS4: return "ps4";
184   case ELFIAMCU: return "elfiamcu";
185   case TvOS: return "tvos";
186   case WatchOS: return "watchos";
187   }
188
189   llvm_unreachable("Invalid OSType");
190 }
191
192 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
193   switch (Kind) {
194   case UnknownEnvironment: return "unknown";
195   case GNU: return "gnu";
196   case GNUEABIHF: return "gnueabihf";
197   case GNUEABI: return "gnueabi";
198   case GNUX32: return "gnux32";
199   case CODE16: return "code16";
200   case EABI: return "eabi";
201   case EABIHF: return "eabihf";
202   case Android: return "android";
203   case MSVC: return "msvc";
204   case Itanium: return "itanium";
205   case Cygnus: return "cygnus";
206   case AMDOpenCL: return "amdopencl";
207   case CoreCLR: return "coreclr";
208   }
209
210   llvm_unreachable("Invalid EnvironmentType!");
211 }
212
213 static Triple::ArchType parseBPFArch(StringRef ArchName) {
214   if (ArchName.equals("bpf")) {
215     if (sys::IsLittleEndianHost)
216       return Triple::bpfel;
217     else
218       return Triple::bpfeb;
219   } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
220     return Triple::bpfeb;
221   } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
222     return Triple::bpfel;
223   } else {
224     return Triple::UnknownArch;
225   }
226 }
227
228 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
229   Triple::ArchType BPFArch(parseBPFArch(Name));
230   return StringSwitch<Triple::ArchType>(Name)
231     .Case("aarch64", aarch64)
232     .Case("aarch64_be", aarch64_be)
233     .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
234     .Case("arm", arm)
235     .Case("armeb", armeb)
236     .Case("avr", avr)
237     .StartsWith("bpf", BPFArch)
238     .Case("mips", mips)
239     .Case("mipsel", mipsel)
240     .Case("mips64", mips64)
241     .Case("mips64el", mips64el)
242     .Case("msp430", msp430)
243     .Case("ppc64", ppc64)
244     .Case("ppc32", ppc)
245     .Case("ppc", ppc)
246     .Case("ppc64le", ppc64le)
247     .Case("r600", r600)
248     .Case("amdgcn", amdgcn)
249     .Case("hexagon", hexagon)
250     .Case("sparc", sparc)
251     .Case("sparcel", sparcel)
252     .Case("sparcv9", sparcv9)
253     .Case("systemz", systemz)
254     .Case("tce", tce)
255     .Case("thumb", thumb)
256     .Case("thumbeb", thumbeb)
257     .Case("x86", x86)
258     .Case("x86-64", x86_64)
259     .Case("xcore", xcore)
260     .Case("nvptx", nvptx)
261     .Case("nvptx64", nvptx64)
262     .Case("le32", le32)
263     .Case("le64", le64)
264     .Case("amdil", amdil)
265     .Case("amdil64", amdil64)
266     .Case("hsail", hsail)
267     .Case("hsail64", hsail64)
268     .Case("spir", spir)
269     .Case("spir64", spir64)
270     .Case("kalimba", kalimba)
271     .Case("shave", shave)
272     .Case("wasm32", wasm32)
273     .Case("wasm64", wasm64)
274     .Default(UnknownArch);
275 }
276
277 static Triple::ArchType parseARMArch(StringRef ArchName) {
278   unsigned ISA = ARM::parseArchISA(ArchName);
279   unsigned ENDIAN = ARM::parseArchEndian(ArchName);
280
281   Triple::ArchType arch = Triple::UnknownArch;
282   switch (ENDIAN) {
283   case ARM::EK_LITTLE: {
284     switch (ISA) {
285     case ARM::IK_ARM:
286       arch = Triple::arm;
287       break;
288     case ARM::IK_THUMB:
289       arch = Triple::thumb;
290       break;
291     case ARM::IK_AARCH64:
292       arch = Triple::aarch64;
293       break;
294     }
295     break;
296   }
297   case ARM::EK_BIG: {
298     switch (ISA) {
299     case ARM::IK_ARM:
300       arch = Triple::armeb;
301       break;
302     case ARM::IK_THUMB:
303       arch = Triple::thumbeb;
304       break;
305     case ARM::IK_AARCH64:
306       arch = Triple::aarch64_be;
307       break;
308     }
309     break;
310   }
311   }
312
313   ArchName = ARM::getCanonicalArchName(ArchName);
314   if (ArchName.empty())
315     return Triple::UnknownArch;
316
317   // Thumb only exists in v4+
318   if (ISA == ARM::IK_THUMB &&
319       (ArchName.startswith("v2") || ArchName.startswith("v3")))
320     return Triple::UnknownArch;
321
322   // Thumb only for v6m
323   unsigned Profile = ARM::parseArchProfile(ArchName);
324   unsigned Version = ARM::parseArchVersion(ArchName);
325   if (Profile == ARM::PK_M && Version == 6) {
326     if (ENDIAN == ARM::EK_BIG)
327       return Triple::thumbeb;
328     else
329       return Triple::thumb;
330   }
331
332   return arch;
333 }
334
335 static Triple::ArchType parseArch(StringRef ArchName) {
336   auto AT = StringSwitch<Triple::ArchType>(ArchName)
337     .Cases("i386", "i486", "i586", "i686", Triple::x86)
338     // FIXME: Do we need to support these?
339     .Cases("i786", "i886", "i986", Triple::x86)
340     .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
341     .Case("powerpc", Triple::ppc)
342     .Cases("powerpc64", "ppu", Triple::ppc64)
343     .Case("powerpc64le", Triple::ppc64le)
344     .Case("xscale", Triple::arm)
345     .Case("xscaleeb", Triple::armeb)
346     .Case("aarch64", Triple::aarch64)
347     .Case("aarch64_be", Triple::aarch64_be)
348     .Case("arm64", Triple::aarch64)
349     .Case("arm", Triple::arm)
350     .Case("armeb", Triple::armeb)
351     .Case("thumb", Triple::thumb)
352     .Case("thumbeb", Triple::thumbeb)
353     .Case("avr", Triple::avr)
354     .Case("msp430", Triple::msp430)
355     .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
356     .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
357     .Cases("mips64", "mips64eb", Triple::mips64)
358     .Case("mips64el", Triple::mips64el)
359     .Case("r600", Triple::r600)
360     .Case("amdgcn", Triple::amdgcn)
361     .Case("hexagon", Triple::hexagon)
362     .Case("s390x", Triple::systemz)
363     .Case("sparc", Triple::sparc)
364     .Case("sparcel", Triple::sparcel)
365     .Cases("sparcv9", "sparc64", Triple::sparcv9)
366     .Case("tce", Triple::tce)
367     .Case("xcore", Triple::xcore)
368     .Case("nvptx", Triple::nvptx)
369     .Case("nvptx64", Triple::nvptx64)
370     .Case("le32", Triple::le32)
371     .Case("le64", Triple::le64)
372     .Case("amdil", Triple::amdil)
373     .Case("amdil64", Triple::amdil64)
374     .Case("hsail", Triple::hsail)
375     .Case("hsail64", Triple::hsail64)
376     .Case("spir", Triple::spir)
377     .Case("spir64", Triple::spir64)
378     .StartsWith("kalimba", Triple::kalimba)
379     .Case("shave", Triple::shave)
380     .Case("wasm32", Triple::wasm32)
381     .Case("wasm64", Triple::wasm64)
382     .Default(Triple::UnknownArch);
383
384   // Some architectures require special parsing logic just to compute the
385   // ArchType result.
386   if (AT == Triple::UnknownArch) {
387     if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
388         ArchName.startswith("aarch64"))
389       return parseARMArch(ArchName);
390     if (ArchName.startswith("bpf"))
391       return parseBPFArch(ArchName);
392   }
393
394   return AT;
395 }
396
397 static Triple::VendorType parseVendor(StringRef VendorName) {
398   return StringSwitch<Triple::VendorType>(VendorName)
399     .Case("apple", Triple::Apple)
400     .Case("pc", Triple::PC)
401     .Case("scei", Triple::SCEI)
402     .Case("bgp", Triple::BGP)
403     .Case("bgq", Triple::BGQ)
404     .Case("fsl", Triple::Freescale)
405     .Case("ibm", Triple::IBM)
406     .Case("img", Triple::ImaginationTechnologies)
407     .Case("mti", Triple::MipsTechnologies)
408     .Case("nvidia", Triple::NVIDIA)
409     .Case("csr", Triple::CSR)
410     .Case("myriad", Triple::Myriad)
411     .Default(Triple::UnknownVendor);
412 }
413
414 static Triple::OSType parseOS(StringRef OSName) {
415   return StringSwitch<Triple::OSType>(OSName)
416     .StartsWith("cloudabi", Triple::CloudABI)
417     .StartsWith("darwin", Triple::Darwin)
418     .StartsWith("dragonfly", Triple::DragonFly)
419     .StartsWith("freebsd", Triple::FreeBSD)
420     .StartsWith("ios", Triple::IOS)
421     .StartsWith("kfreebsd", Triple::KFreeBSD)
422     .StartsWith("linux", Triple::Linux)
423     .StartsWith("lv2", Triple::Lv2)
424     .StartsWith("macosx", Triple::MacOSX)
425     .StartsWith("netbsd", Triple::NetBSD)
426     .StartsWith("openbsd", Triple::OpenBSD)
427     .StartsWith("solaris", Triple::Solaris)
428     .StartsWith("win32", Triple::Win32)
429     .StartsWith("windows", Triple::Win32)
430     .StartsWith("haiku", Triple::Haiku)
431     .StartsWith("minix", Triple::Minix)
432     .StartsWith("rtems", Triple::RTEMS)
433     .StartsWith("nacl", Triple::NaCl)
434     .StartsWith("cnk", Triple::CNK)
435     .StartsWith("bitrig", Triple::Bitrig)
436     .StartsWith("aix", Triple::AIX)
437     .StartsWith("cuda", Triple::CUDA)
438     .StartsWith("nvcl", Triple::NVCL)
439     .StartsWith("amdhsa", Triple::AMDHSA)
440     .StartsWith("ps4", Triple::PS4)
441     .StartsWith("elfiamcu", Triple::ELFIAMCU)
442     .StartsWith("tvos", Triple::TvOS)
443     .StartsWith("watchos", Triple::WatchOS)
444     .Default(Triple::UnknownOS);
445 }
446
447 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
448   return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
449     .StartsWith("eabihf", Triple::EABIHF)
450     .StartsWith("eabi", Triple::EABI)
451     .StartsWith("gnueabihf", Triple::GNUEABIHF)
452     .StartsWith("gnueabi", Triple::GNUEABI)
453     .StartsWith("gnux32", Triple::GNUX32)
454     .StartsWith("code16", Triple::CODE16)
455     .StartsWith("gnu", Triple::GNU)
456     .StartsWith("android", Triple::Android)
457     .StartsWith("msvc", Triple::MSVC)
458     .StartsWith("itanium", Triple::Itanium)
459     .StartsWith("cygnus", Triple::Cygnus)
460     .StartsWith("amdopencl", Triple::AMDOpenCL)
461     .StartsWith("coreclr", Triple::CoreCLR)
462     .Default(Triple::UnknownEnvironment);
463 }
464
465 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
466   return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
467     .EndsWith("coff", Triple::COFF)
468     .EndsWith("elf", Triple::ELF)
469     .EndsWith("macho", Triple::MachO)
470     .Default(Triple::UnknownObjectFormat);
471 }
472
473 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
474   StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
475
476   // For now, this is the small part. Early return.
477   if (ARMSubArch.empty())
478     return StringSwitch<Triple::SubArchType>(SubArchName)
479       .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
480       .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
481       .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
482       .Default(Triple::NoSubArch);
483
484   // ARM sub arch.
485   switch(ARM::parseArch(ARMSubArch)) {
486   case ARM::AK_ARMV4:
487     return Triple::NoSubArch;
488   case ARM::AK_ARMV4T:
489     return Triple::ARMSubArch_v4t;
490   case ARM::AK_ARMV5T:
491     return Triple::ARMSubArch_v5;
492   case ARM::AK_ARMV5TE:
493   case ARM::AK_IWMMXT:
494   case ARM::AK_IWMMXT2:
495   case ARM::AK_XSCALE:
496   case ARM::AK_ARMV5TEJ:
497     return Triple::ARMSubArch_v5te;
498   case ARM::AK_ARMV6:
499   case ARM::AK_ARMV6J:
500     return Triple::ARMSubArch_v6;
501   case ARM::AK_ARMV6K:
502   case ARM::AK_ARMV6KZ:
503     return Triple::ARMSubArch_v6k;
504   case ARM::AK_ARMV6T2:
505     return Triple::ARMSubArch_v6t2;
506   case ARM::AK_ARMV6M:
507     return Triple::ARMSubArch_v6m;
508   case ARM::AK_ARMV7A:
509   case ARM::AK_ARMV7R:
510     return Triple::ARMSubArch_v7;
511   case ARM::AK_ARMV7K:
512     return Triple::ARMSubArch_v7k;
513   case ARM::AK_ARMV7M:
514     return Triple::ARMSubArch_v7m;
515   case ARM::AK_ARMV7S:
516     return Triple::ARMSubArch_v7s;
517   case ARM::AK_ARMV7EM:
518     return Triple::ARMSubArch_v7em;
519   case ARM::AK_ARMV8A:
520     return Triple::ARMSubArch_v8;
521   case ARM::AK_ARMV8_1A:
522     return Triple::ARMSubArch_v8_1a;
523   default:
524     return Triple::NoSubArch;
525   }
526 }
527
528 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
529   switch (Kind) {
530   case Triple::UnknownObjectFormat: return "";
531   case Triple::COFF: return "coff";
532   case Triple::ELF: return "elf";
533   case Triple::MachO: return "macho";
534   }
535   llvm_unreachable("unknown object format type");
536 }
537
538 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
539   switch (T.getArch()) {
540   default:
541     break;
542   case Triple::hexagon:
543   case Triple::mips:
544   case Triple::mipsel:
545   case Triple::mips64:
546   case Triple::mips64el:
547   case Triple::r600:
548   case Triple::amdgcn:
549   case Triple::sparc:
550   case Triple::sparcv9:
551   case Triple::systemz:
552   case Triple::xcore:
553   case Triple::ppc64le:
554     return Triple::ELF;
555
556   case Triple::ppc:
557   case Triple::ppc64:
558     if (T.isOSDarwin())
559       return Triple::MachO;
560     return Triple::ELF;
561
562   case Triple::wasm32:
563   case Triple::wasm64:
564     // Unknown for now, until an object format is specified.
565     return Triple::UnknownObjectFormat;
566   }
567
568   if (T.isOSDarwin())
569     return Triple::MachO;
570   else if (T.isOSWindows())
571     return Triple::COFF;
572   return Triple::ELF;
573 }
574
575 /// \brief Construct a triple from the string representation provided.
576 ///
577 /// This stores the string representation and parses the various pieces into
578 /// enum members.
579 Triple::Triple(const Twine &Str)
580     : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
581       Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
582       ObjectFormat(UnknownObjectFormat) {
583   // Do minimal parsing by hand here.
584   SmallVector<StringRef, 4> Components;
585   StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
586   if (Components.size() > 0) {
587     Arch = parseArch(Components[0]);
588     SubArch = parseSubArch(Components[0]);
589     if (Components.size() > 1) {
590       Vendor = parseVendor(Components[1]);
591       if (Components.size() > 2) {
592         OS = parseOS(Components[2]);
593         if (Components.size() > 3) {
594           Environment = parseEnvironment(Components[3]);
595           ObjectFormat = parseFormat(Components[3]);
596         }
597       }
598     }
599   }
600   if (ObjectFormat == UnknownObjectFormat)
601     ObjectFormat = getDefaultFormat(*this);
602 }
603
604 /// \brief Construct a triple from string representations of the architecture,
605 /// vendor, and OS.
606 ///
607 /// This joins each argument into a canonical string representation and parses
608 /// them into enum members. It leaves the environment unknown and omits it from
609 /// the string representation.
610 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
611     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
612       Arch(parseArch(ArchStr.str())),
613       SubArch(parseSubArch(ArchStr.str())),
614       Vendor(parseVendor(VendorStr.str())),
615       OS(parseOS(OSStr.str())),
616       Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
617   ObjectFormat = getDefaultFormat(*this);
618 }
619
620 /// \brief Construct a triple from string representations of the architecture,
621 /// vendor, OS, and environment.
622 ///
623 /// This joins each argument into a canonical string representation and parses
624 /// them into enum members.
625 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
626                const Twine &EnvironmentStr)
627     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
628             EnvironmentStr).str()),
629       Arch(parseArch(ArchStr.str())),
630       SubArch(parseSubArch(ArchStr.str())),
631       Vendor(parseVendor(VendorStr.str())),
632       OS(parseOS(OSStr.str())),
633       Environment(parseEnvironment(EnvironmentStr.str())),
634       ObjectFormat(parseFormat(EnvironmentStr.str())) {
635   if (ObjectFormat == Triple::UnknownObjectFormat)
636     ObjectFormat = getDefaultFormat(*this);
637 }
638
639 std::string Triple::normalize(StringRef Str) {
640   bool IsMinGW32 = false;
641   bool IsCygwin = false;
642
643   // Parse into components.
644   SmallVector<StringRef, 4> Components;
645   Str.split(Components, '-');
646
647   // If the first component corresponds to a known architecture, preferentially
648   // use it for the architecture.  If the second component corresponds to a
649   // known vendor, preferentially use it for the vendor, etc.  This avoids silly
650   // component movement when a component parses as (eg) both a valid arch and a
651   // valid os.
652   ArchType Arch = UnknownArch;
653   if (Components.size() > 0)
654     Arch = parseArch(Components[0]);
655   VendorType Vendor = UnknownVendor;
656   if (Components.size() > 1)
657     Vendor = parseVendor(Components[1]);
658   OSType OS = UnknownOS;
659   if (Components.size() > 2) {
660     OS = parseOS(Components[2]);
661     IsCygwin = Components[2].startswith("cygwin");
662     IsMinGW32 = Components[2].startswith("mingw");
663   }
664   EnvironmentType Environment = UnknownEnvironment;
665   if (Components.size() > 3)
666     Environment = parseEnvironment(Components[3]);
667   ObjectFormatType ObjectFormat = UnknownObjectFormat;
668   if (Components.size() > 4)
669     ObjectFormat = parseFormat(Components[4]);
670
671   // Note which components are already in their final position.  These will not
672   // be moved.
673   bool Found[4];
674   Found[0] = Arch != UnknownArch;
675   Found[1] = Vendor != UnknownVendor;
676   Found[2] = OS != UnknownOS;
677   Found[3] = Environment != UnknownEnvironment;
678
679   // If they are not there already, permute the components into their canonical
680   // positions by seeing if they parse as a valid architecture, and if so moving
681   // the component to the architecture position etc.
682   for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
683     if (Found[Pos])
684       continue; // Already in the canonical position.
685
686     for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
687       // Do not reparse any components that already matched.
688       if (Idx < array_lengthof(Found) && Found[Idx])
689         continue;
690
691       // Does this component parse as valid for the target position?
692       bool Valid = false;
693       StringRef Comp = Components[Idx];
694       switch (Pos) {
695       default: llvm_unreachable("unexpected component type!");
696       case 0:
697         Arch = parseArch(Comp);
698         Valid = Arch != UnknownArch;
699         break;
700       case 1:
701         Vendor = parseVendor(Comp);
702         Valid = Vendor != UnknownVendor;
703         break;
704       case 2:
705         OS = parseOS(Comp);
706         IsCygwin = Comp.startswith("cygwin");
707         IsMinGW32 = Comp.startswith("mingw");
708         Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
709         break;
710       case 3:
711         Environment = parseEnvironment(Comp);
712         Valid = Environment != UnknownEnvironment;
713         if (!Valid) {
714           ObjectFormat = parseFormat(Comp);
715           Valid = ObjectFormat != UnknownObjectFormat;
716         }
717         break;
718       }
719       if (!Valid)
720         continue; // Nope, try the next component.
721
722       // Move the component to the target position, pushing any non-fixed
723       // components that are in the way to the right.  This tends to give
724       // good results in the common cases of a forgotten vendor component
725       // or a wrongly positioned environment.
726       if (Pos < Idx) {
727         // Insert left, pushing the existing components to the right.  For
728         // example, a-b-i386 -> i386-a-b when moving i386 to the front.
729         StringRef CurrentComponent(""); // The empty component.
730         // Replace the component we are moving with an empty component.
731         std::swap(CurrentComponent, Components[Idx]);
732         // Insert the component being moved at Pos, displacing any existing
733         // components to the right.
734         for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
735           // Skip over any fixed components.
736           while (i < array_lengthof(Found) && Found[i])
737             ++i;
738           // Place the component at the new position, getting the component
739           // that was at this position - it will be moved right.
740           std::swap(CurrentComponent, Components[i]);
741         }
742       } else if (Pos > Idx) {
743         // Push right by inserting empty components until the component at Idx
744         // reaches the target position Pos.  For example, pc-a -> -pc-a when
745         // moving pc to the second position.
746         do {
747           // Insert one empty component at Idx.
748           StringRef CurrentComponent(""); // The empty component.
749           for (unsigned i = Idx; i < Components.size();) {
750             // Place the component at the new position, getting the component
751             // that was at this position - it will be moved right.
752             std::swap(CurrentComponent, Components[i]);
753             // If it was placed on top of an empty component then we are done.
754             if (CurrentComponent.empty())
755               break;
756             // Advance to the next component, skipping any fixed components.
757             while (++i < array_lengthof(Found) && Found[i])
758               ;
759           }
760           // The last component was pushed off the end - append it.
761           if (!CurrentComponent.empty())
762             Components.push_back(CurrentComponent);
763
764           // Advance Idx to the component's new position.
765           while (++Idx < array_lengthof(Found) && Found[Idx])
766             ;
767         } while (Idx < Pos); // Add more until the final position is reached.
768       }
769       assert(Pos < Components.size() && Components[Pos] == Comp &&
770              "Component moved wrong!");
771       Found[Pos] = true;
772       break;
773     }
774   }
775
776   // Special case logic goes here.  At this point Arch, Vendor and OS have the
777   // correct values for the computed components.
778   std::string NormalizedEnvironment;
779   if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
780     StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
781     if (AndroidVersion.empty()) {
782       Components[3] = "android";
783     } else {
784       NormalizedEnvironment = Twine("android", AndroidVersion).str();
785       Components[3] = NormalizedEnvironment;
786     }
787   }
788
789   if (OS == Triple::Win32) {
790     Components.resize(4);
791     Components[2] = "windows";
792     if (Environment == UnknownEnvironment) {
793       if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
794         Components[3] = "msvc";
795       else
796         Components[3] = getObjectFormatTypeName(ObjectFormat);
797     }
798   } else if (IsMinGW32) {
799     Components.resize(4);
800     Components[2] = "windows";
801     Components[3] = "gnu";
802   } else if (IsCygwin) {
803     Components.resize(4);
804     Components[2] = "windows";
805     Components[3] = "cygnus";
806   }
807   if (IsMinGW32 || IsCygwin ||
808       (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
809     if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
810       Components.resize(5);
811       Components[4] = getObjectFormatTypeName(ObjectFormat);
812     }
813   }
814
815   // Stick the corrected components back together to form the normalized string.
816   std::string Normalized;
817   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
818     if (i) Normalized += '-';
819     Normalized += Components[i];
820   }
821   return Normalized;
822 }
823
824 StringRef Triple::getArchName() const {
825   return StringRef(Data).split('-').first;           // Isolate first component
826 }
827
828 StringRef Triple::getVendorName() const {
829   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
830   return Tmp.split('-').first;                       // Isolate second component
831 }
832
833 StringRef Triple::getOSName() const {
834   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
835   Tmp = Tmp.split('-').second;                       // Strip second component
836   return Tmp.split('-').first;                       // Isolate third component
837 }
838
839 StringRef Triple::getEnvironmentName() const {
840   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
841   Tmp = Tmp.split('-').second;                       // Strip second component
842   return Tmp.split('-').second;                      // Strip third component
843 }
844
845 StringRef Triple::getOSAndEnvironmentName() const {
846   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
847   return Tmp.split('-').second;                      // Strip second component
848 }
849
850 static unsigned EatNumber(StringRef &Str) {
851   assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
852   unsigned Result = 0;
853
854   do {
855     // Consume the leading digit.
856     Result = Result*10 + (Str[0] - '0');
857
858     // Eat the digit.
859     Str = Str.substr(1);
860   } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
861
862   return Result;
863 }
864
865 static void parseVersionFromName(StringRef Name, unsigned &Major,
866                                  unsigned &Minor, unsigned &Micro) {
867   // Any unset version defaults to 0.
868   Major = Minor = Micro = 0;
869
870   // Parse up to three components.
871   unsigned *Components[3] = {&Major, &Minor, &Micro};
872   for (unsigned i = 0; i != 3; ++i) {
873     if (Name.empty() || Name[0] < '0' || Name[0] > '9')
874       break;
875
876     // Consume the leading number.
877     *Components[i] = EatNumber(Name);
878
879     // Consume the separator, if present.
880     if (Name.startswith("."))
881       Name = Name.substr(1);
882   }
883 }
884
885 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
886                                    unsigned &Micro) const {
887   StringRef EnvironmentName = getEnvironmentName();
888   StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
889   if (EnvironmentName.startswith(EnvironmentTypeName))
890     EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
891
892   parseVersionFromName(EnvironmentName, Major, Minor, Micro);
893 }
894
895 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
896                           unsigned &Micro) const {
897   StringRef OSName = getOSName();
898   // Assume that the OS portion of the triple starts with the canonical name.
899   StringRef OSTypeName = getOSTypeName(getOS());
900   if (OSName.startswith(OSTypeName))
901     OSName = OSName.substr(OSTypeName.size());
902
903   parseVersionFromName(OSName, Major, Minor, Micro);
904 }
905
906 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
907                               unsigned &Micro) const {
908   getOSVersion(Major, Minor, Micro);
909
910   switch (getOS()) {
911   default: llvm_unreachable("unexpected OS for Darwin triple");
912   case Darwin:
913     // Default to darwin8, i.e., MacOSX 10.4.
914     if (Major == 0)
915       Major = 8;
916     // Darwin version numbers are skewed from OS X versions.
917     if (Major < 4)
918       return false;
919     Micro = 0;
920     Minor = Major - 4;
921     Major = 10;
922     break;
923   case MacOSX:
924     // Default to 10.4.
925     if (Major == 0) {
926       Major = 10;
927       Minor = 4;
928     }
929     if (Major != 10)
930       return false;
931     break;
932   case IOS:
933   case TvOS:
934   case WatchOS:
935     // Ignore the version from the triple.  This is only handled because the
936     // the clang driver combines OS X and IOS support into a common Darwin
937     // toolchain that wants to know the OS X version number even when targeting
938     // IOS.
939     Major = 10;
940     Minor = 4;
941     Micro = 0;
942     break;
943   }
944   return true;
945 }
946
947 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
948                            unsigned &Micro) const {
949   switch (getOS()) {
950   default: llvm_unreachable("unexpected OS for Darwin triple");
951   case Darwin:
952   case MacOSX:
953     // Ignore the version from the triple.  This is only handled because the
954     // the clang driver combines OS X and IOS support into a common Darwin
955     // toolchain that wants to know the iOS version number even when targeting
956     // OS X.
957     Major = 5;
958     Minor = 0;
959     Micro = 0;
960     break;
961   case IOS:
962   case TvOS:
963     getOSVersion(Major, Minor, Micro);
964     // Default to 5.0 (or 7.0 for arm64).
965     if (Major == 0)
966       Major = (getArch() == aarch64) ? 7 : 5;
967     break;
968   case WatchOS:
969     llvm_unreachable("conflicting triple info");
970   }
971 }
972
973 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
974                                unsigned &Micro) const {
975   switch (getOS()) {
976   default: llvm_unreachable("unexpected OS for Darwin triple");
977   case Darwin:
978   case MacOSX:
979     // Ignore the version from the triple.  This is only handled because the
980     // the clang driver combines OS X and IOS support into a common Darwin
981     // toolchain that wants to know the iOS version number even when targeting
982     // OS X.
983     Major = 2;
984     Minor = 0;
985     Micro = 0;
986     break;
987   case WatchOS:
988     getOSVersion(Major, Minor, Micro);
989     if (Major == 0)
990       Major = 2;
991     break;
992   case IOS:
993     llvm_unreachable("conflicting triple info");
994   }
995 }
996
997 void Triple::setTriple(const Twine &Str) {
998   *this = Triple(Str);
999 }
1000
1001 void Triple::setArch(ArchType Kind) {
1002   setArchName(getArchTypeName(Kind));
1003 }
1004
1005 void Triple::setVendor(VendorType Kind) {
1006   setVendorName(getVendorTypeName(Kind));
1007 }
1008
1009 void Triple::setOS(OSType Kind) {
1010   setOSName(getOSTypeName(Kind));
1011 }
1012
1013 void Triple::setEnvironment(EnvironmentType Kind) {
1014   if (ObjectFormat == getDefaultFormat(*this))
1015     return setEnvironmentName(getEnvironmentTypeName(Kind));
1016
1017   setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1018                       getObjectFormatTypeName(ObjectFormat)).str());
1019 }
1020
1021 void Triple::setObjectFormat(ObjectFormatType Kind) {
1022   if (Environment == UnknownEnvironment)
1023     return setEnvironmentName(getObjectFormatTypeName(Kind));
1024
1025   setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1026                       getObjectFormatTypeName(Kind)).str());
1027 }
1028
1029 void Triple::setArchName(StringRef Str) {
1030   // Work around a miscompilation bug for Twines in gcc 4.0.3.
1031   SmallString<64> Triple;
1032   Triple += Str;
1033   Triple += "-";
1034   Triple += getVendorName();
1035   Triple += "-";
1036   Triple += getOSAndEnvironmentName();
1037   setTriple(Triple);
1038 }
1039
1040 void Triple::setVendorName(StringRef Str) {
1041   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1042 }
1043
1044 void Triple::setOSName(StringRef Str) {
1045   if (hasEnvironment())
1046     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1047               "-" + getEnvironmentName());
1048   else
1049     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1050 }
1051
1052 void Triple::setEnvironmentName(StringRef Str) {
1053   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1054             "-" + Str);
1055 }
1056
1057 void Triple::setOSAndEnvironmentName(StringRef Str) {
1058   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1059 }
1060
1061 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1062   switch (Arch) {
1063   case llvm::Triple::UnknownArch:
1064     return 0;
1065
1066   case llvm::Triple::avr:
1067   case llvm::Triple::msp430:
1068     return 16;
1069
1070   case llvm::Triple::arm:
1071   case llvm::Triple::armeb:
1072   case llvm::Triple::hexagon:
1073   case llvm::Triple::le32:
1074   case llvm::Triple::mips:
1075   case llvm::Triple::mipsel:
1076   case llvm::Triple::nvptx:
1077   case llvm::Triple::ppc:
1078   case llvm::Triple::r600:
1079   case llvm::Triple::sparc:
1080   case llvm::Triple::sparcel:
1081   case llvm::Triple::tce:
1082   case llvm::Triple::thumb:
1083   case llvm::Triple::thumbeb:
1084   case llvm::Triple::x86:
1085   case llvm::Triple::xcore:
1086   case llvm::Triple::amdil:
1087   case llvm::Triple::hsail:
1088   case llvm::Triple::spir:
1089   case llvm::Triple::kalimba:
1090   case llvm::Triple::shave:
1091   case llvm::Triple::wasm32:
1092     return 32;
1093
1094   case llvm::Triple::aarch64:
1095   case llvm::Triple::aarch64_be:
1096   case llvm::Triple::amdgcn:
1097   case llvm::Triple::bpfel:
1098   case llvm::Triple::bpfeb:
1099   case llvm::Triple::le64:
1100   case llvm::Triple::mips64:
1101   case llvm::Triple::mips64el:
1102   case llvm::Triple::nvptx64:
1103   case llvm::Triple::ppc64:
1104   case llvm::Triple::ppc64le:
1105   case llvm::Triple::sparcv9:
1106   case llvm::Triple::systemz:
1107   case llvm::Triple::x86_64:
1108   case llvm::Triple::amdil64:
1109   case llvm::Triple::hsail64:
1110   case llvm::Triple::spir64:
1111   case llvm::Triple::wasm64:
1112     return 64;
1113   }
1114   llvm_unreachable("Invalid architecture value");
1115 }
1116
1117 bool Triple::isArch64Bit() const {
1118   return getArchPointerBitWidth(getArch()) == 64;
1119 }
1120
1121 bool Triple::isArch32Bit() const {
1122   return getArchPointerBitWidth(getArch()) == 32;
1123 }
1124
1125 bool Triple::isArch16Bit() const {
1126   return getArchPointerBitWidth(getArch()) == 16;
1127 }
1128
1129 Triple Triple::get32BitArchVariant() const {
1130   Triple T(*this);
1131   switch (getArch()) {
1132   case Triple::UnknownArch:
1133   case Triple::aarch64:
1134   case Triple::aarch64_be:
1135   case Triple::amdgcn:
1136   case Triple::avr:
1137   case Triple::bpfel:
1138   case Triple::bpfeb:
1139   case Triple::msp430:
1140   case Triple::systemz:
1141   case Triple::ppc64le:
1142     T.setArch(UnknownArch);
1143     break;
1144
1145   case Triple::amdil:
1146   case Triple::hsail:
1147   case Triple::spir:
1148   case Triple::arm:
1149   case Triple::armeb:
1150   case Triple::hexagon:
1151   case Triple::kalimba:
1152   case Triple::le32:
1153   case Triple::mips:
1154   case Triple::mipsel:
1155   case Triple::nvptx:
1156   case Triple::ppc:
1157   case Triple::r600:
1158   case Triple::sparc:
1159   case Triple::sparcel:
1160   case Triple::tce:
1161   case Triple::thumb:
1162   case Triple::thumbeb:
1163   case Triple::x86:
1164   case Triple::xcore:
1165   case Triple::shave:
1166   case Triple::wasm32:
1167     // Already 32-bit.
1168     break;
1169
1170   case Triple::le64:      T.setArch(Triple::le32);    break;
1171   case Triple::mips64:    T.setArch(Triple::mips);    break;
1172   case Triple::mips64el:  T.setArch(Triple::mipsel);  break;
1173   case Triple::nvptx64:   T.setArch(Triple::nvptx);   break;
1174   case Triple::ppc64:     T.setArch(Triple::ppc);     break;
1175   case Triple::sparcv9:   T.setArch(Triple::sparc);   break;
1176   case Triple::x86_64:    T.setArch(Triple::x86);     break;
1177   case Triple::amdil64:   T.setArch(Triple::amdil);   break;
1178   case Triple::hsail64:   T.setArch(Triple::hsail);   break;
1179   case Triple::spir64:    T.setArch(Triple::spir);    break;
1180   case Triple::wasm64:    T.setArch(Triple::wasm32);  break;
1181   }
1182   return T;
1183 }
1184
1185 Triple Triple::get64BitArchVariant() const {
1186   Triple T(*this);
1187   switch (getArch()) {
1188   case Triple::UnknownArch:
1189   case Triple::arm:
1190   case Triple::armeb:
1191   case Triple::avr:
1192   case Triple::hexagon:
1193   case Triple::kalimba:
1194   case Triple::msp430:
1195   case Triple::r600:
1196   case Triple::tce:
1197   case Triple::thumb:
1198   case Triple::thumbeb:
1199   case Triple::xcore:
1200   case Triple::sparcel:
1201   case Triple::shave:
1202     T.setArch(UnknownArch);
1203     break;
1204
1205   case Triple::aarch64:
1206   case Triple::aarch64_be:
1207   case Triple::bpfel:
1208   case Triple::bpfeb:
1209   case Triple::le64:
1210   case Triple::amdil64:
1211   case Triple::amdgcn:
1212   case Triple::hsail64:
1213   case Triple::spir64:
1214   case Triple::mips64:
1215   case Triple::mips64el:
1216   case Triple::nvptx64:
1217   case Triple::ppc64:
1218   case Triple::ppc64le:
1219   case Triple::sparcv9:
1220   case Triple::systemz:
1221   case Triple::x86_64:
1222   case Triple::wasm64:
1223     // Already 64-bit.
1224     break;
1225
1226   case Triple::le32:    T.setArch(Triple::le64);      break;
1227   case Triple::mips:    T.setArch(Triple::mips64);    break;
1228   case Triple::mipsel:  T.setArch(Triple::mips64el);  break;
1229   case Triple::nvptx:   T.setArch(Triple::nvptx64);   break;
1230   case Triple::ppc:     T.setArch(Triple::ppc64);     break;
1231   case Triple::sparc:   T.setArch(Triple::sparcv9);   break;
1232   case Triple::x86:     T.setArch(Triple::x86_64);    break;
1233   case Triple::amdil:   T.setArch(Triple::amdil64);   break;
1234   case Triple::hsail:   T.setArch(Triple::hsail64);   break;
1235   case Triple::spir:    T.setArch(Triple::spir64);    break;
1236   case Triple::wasm32:  T.setArch(Triple::wasm64);    break;
1237   }
1238   return T;
1239 }
1240
1241 Triple Triple::getBigEndianArchVariant() const {
1242   Triple T(*this);
1243   switch (getArch()) {
1244   case Triple::UnknownArch:
1245   case Triple::amdgcn:
1246   case Triple::amdil64:
1247   case Triple::amdil:
1248   case Triple::avr:
1249   case Triple::hexagon:
1250   case Triple::hsail64:
1251   case Triple::hsail:
1252   case Triple::kalimba:
1253   case Triple::le32:
1254   case Triple::le64:
1255   case Triple::msp430:
1256   case Triple::nvptx64:
1257   case Triple::nvptx:
1258   case Triple::r600:
1259   case Triple::shave:
1260   case Triple::spir64:
1261   case Triple::spir:
1262   case Triple::wasm32:
1263   case Triple::wasm64:
1264   case Triple::x86:
1265   case Triple::x86_64:
1266   case Triple::xcore:
1267
1268   // ARM is intentionally unsupported here, changing the architecture would
1269   // drop any arch suffixes.
1270   case Triple::arm:
1271   case Triple::thumb:
1272     T.setArch(UnknownArch);
1273     break;
1274
1275   case Triple::aarch64_be:
1276   case Triple::armeb:
1277   case Triple::bpfeb:
1278   case Triple::mips64:
1279   case Triple::mips:
1280   case Triple::ppc64:
1281   case Triple::ppc:
1282   case Triple::sparc:
1283   case Triple::sparcv9:
1284   case Triple::systemz:
1285   case Triple::tce:
1286   case Triple::thumbeb:
1287     // Already big endian.
1288     break;
1289
1290   case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1291   case Triple::bpfel:   T.setArch(Triple::bpfeb);      break;
1292   case Triple::mips64el:T.setArch(Triple::mips64);     break;
1293   case Triple::mipsel:  T.setArch(Triple::mips);       break;
1294   case Triple::ppc64le: T.setArch(Triple::ppc64);      break;
1295   case Triple::sparcel: T.setArch(Triple::sparc);      break;
1296   }
1297   return T;
1298 }
1299
1300 Triple Triple::getLittleEndianArchVariant() const {
1301   Triple T(*this);
1302   switch (getArch()) {
1303   case Triple::UnknownArch:
1304   case Triple::ppc:
1305   case Triple::sparcv9:
1306   case Triple::systemz:
1307   case Triple::tce:
1308
1309   // ARM is intentionally unsupported here, changing the architecture would
1310   // drop any arch suffixes.
1311   case Triple::armeb:
1312   case Triple::thumbeb:
1313     T.setArch(UnknownArch);
1314     break;
1315
1316   case Triple::aarch64:
1317   case Triple::amdgcn:
1318   case Triple::amdil64:
1319   case Triple::amdil:
1320   case Triple::arm:
1321   case Triple::avr:
1322   case Triple::bpfel:
1323   case Triple::hexagon:
1324   case Triple::hsail64:
1325   case Triple::hsail:
1326   case Triple::kalimba:
1327   case Triple::le32:
1328   case Triple::le64:
1329   case Triple::mips64el:
1330   case Triple::mipsel:
1331   case Triple::msp430:
1332   case Triple::nvptx64:
1333   case Triple::nvptx:
1334   case Triple::ppc64le:
1335   case Triple::r600:
1336   case Triple::shave:
1337   case Triple::sparcel:
1338   case Triple::spir64:
1339   case Triple::spir:
1340   case Triple::thumb:
1341   case Triple::wasm32:
1342   case Triple::wasm64:
1343   case Triple::x86:
1344   case Triple::x86_64:
1345   case Triple::xcore:
1346     // Already little endian.
1347     break;
1348
1349   case Triple::aarch64_be: T.setArch(Triple::aarch64);  break;
1350   case Triple::bpfeb:      T.setArch(Triple::bpfel);    break;
1351   case Triple::mips64:     T.setArch(Triple::mips64el); break;
1352   case Triple::mips:       T.setArch(Triple::mipsel);   break;
1353   case Triple::ppc64:      T.setArch(Triple::ppc64le);  break;
1354   case Triple::sparc:      T.setArch(Triple::sparcel);  break;
1355   }
1356   return T;
1357 }
1358
1359 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1360   if (MArch.empty())
1361     MArch = getArchName();
1362   MArch = ARM::getCanonicalArchName(MArch);
1363
1364   // Some defaults are forced.
1365   switch (getOS()) {
1366   case llvm::Triple::FreeBSD:
1367   case llvm::Triple::NetBSD:
1368     if (!MArch.empty() && MArch == "v6")
1369       return "arm1176jzf-s";
1370     break;
1371   case llvm::Triple::Win32:
1372     // FIXME: this is invalid for WindowsCE
1373     return "cortex-a9";
1374   default:
1375     break;
1376   }
1377
1378   if (MArch.empty())
1379     return StringRef();
1380
1381   StringRef CPU = ARM::getDefaultCPU(MArch);
1382   if (!CPU.empty())
1383     return CPU;
1384
1385   // If no specific architecture version is requested, return the minimum CPU
1386   // required by the OS and environment.
1387   switch (getOS()) {
1388   case llvm::Triple::NetBSD:
1389     switch (getEnvironment()) {
1390     case llvm::Triple::GNUEABIHF:
1391     case llvm::Triple::GNUEABI:
1392     case llvm::Triple::EABIHF:
1393     case llvm::Triple::EABI:
1394       return "arm926ej-s";
1395     default:
1396       return "strongarm";
1397     }
1398   case llvm::Triple::NaCl:
1399     return "cortex-a8";
1400   default:
1401     switch (getEnvironment()) {
1402     case llvm::Triple::EABIHF:
1403     case llvm::Triple::GNUEABIHF:
1404       return "arm1176jzf-s";
1405     default:
1406       return "arm7tdmi";
1407     }
1408   }
1409
1410   llvm_unreachable("invalid arch name");
1411 }