Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 1698 insertions, 1698 deletions

diff --git a/contrib/libs/llvm12/lib/Support/Triple.cpp b/contrib/libs/llvm12/lib/Support/Triple.cpp
index 4f483c9652..6bc2169f7f 100644
--- a/contrib/libs/llvm12/lib/Support/Triple.cpp
+++ b/contrib/libs/llvm12/lib/Support/Triple.cpp
@@ -1,541 +1,541 @@
-//===--- Triple.cpp - Target triple helper class --------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/Triple.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/Host.h"
-#include "llvm/Support/SwapByteOrder.h"
-#include "llvm/Support/TargetParser.h"
-#include "llvm/Support/VersionTuple.h"
-#include <cassert>
-#include <cstring>
-using namespace llvm;
-
-StringRef Triple::getArchTypeName(ArchType Kind) {
-  switch (Kind) {
-  case UnknownArch:    return "unknown";
-
-  case aarch64:        return "aarch64";
-  case aarch64_32:     return "aarch64_32";
-  case aarch64_be:     return "aarch64_be";
-  case amdgcn:         return "amdgcn";
-  case amdil64:        return "amdil64";
-  case amdil:          return "amdil";
-  case arc:            return "arc";
-  case arm:            return "arm";
-  case armeb:          return "armeb";
-  case avr:            return "avr";
-  case bpfeb:          return "bpfeb";
-  case bpfel:          return "bpfel";
+//===--- Triple.cpp - Target triple helper class --------------------------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include "llvm/ADT/Triple.h" 
+#include "llvm/ADT/STLExtras.h" 
+#include "llvm/ADT/SmallString.h" 
+#include "llvm/ADT/StringExtras.h" 
+#include "llvm/ADT/StringSwitch.h" 
+#include "llvm/Support/ErrorHandling.h" 
+#include "llvm/Support/Host.h" 
+#include "llvm/Support/SwapByteOrder.h" 
+#include "llvm/Support/TargetParser.h" 
+#include "llvm/Support/VersionTuple.h" 
+#include <cassert> 
+#include <cstring> 
+using namespace llvm; 
+ 
+StringRef Triple::getArchTypeName(ArchType Kind) { 
+  switch (Kind) { 
+  case UnknownArch:    return "unknown"; 
+ 
+  case aarch64:        return "aarch64"; 
+  case aarch64_32:     return "aarch64_32"; 
+  case aarch64_be:     return "aarch64_be"; 
+  case amdgcn:         return "amdgcn"; 
+  case amdil64:        return "amdil64"; 
+  case amdil:          return "amdil"; 
+  case arc:            return "arc"; 
+  case arm:            return "arm"; 
+  case armeb:          return "armeb"; 
+  case avr:            return "avr"; 
+  case bpfeb:          return "bpfeb"; 
+  case bpfel:          return "bpfel"; 
   case csky:           return "csky";
-  case hexagon:        return "hexagon";
-  case hsail64:        return "hsail64";
-  case hsail:          return "hsail";
-  case kalimba:        return "kalimba";
-  case lanai:          return "lanai";
-  case le32:           return "le32";
-  case le64:           return "le64";
-  case mips64:         return "mips64";
-  case mips64el:       return "mips64el";
-  case mips:           return "mips";
-  case mipsel:         return "mipsel";
-  case msp430:         return "msp430";
-  case nvptx64:        return "nvptx64";
-  case nvptx:          return "nvptx";
-  case ppc64:          return "powerpc64";
-  case ppc64le:        return "powerpc64le";
-  case ppc:            return "powerpc";
+  case hexagon:        return "hexagon"; 
+  case hsail64:        return "hsail64"; 
+  case hsail:          return "hsail"; 
+  case kalimba:        return "kalimba"; 
+  case lanai:          return "lanai"; 
+  case le32:           return "le32"; 
+  case le64:           return "le64"; 
+  case mips64:         return "mips64"; 
+  case mips64el:       return "mips64el"; 
+  case mips:           return "mips"; 
+  case mipsel:         return "mipsel"; 
+  case msp430:         return "msp430"; 
+  case nvptx64:        return "nvptx64"; 
+  case nvptx:          return "nvptx"; 
+  case ppc64:          return "powerpc64"; 
+  case ppc64le:        return "powerpc64le"; 
+  case ppc:            return "powerpc"; 
   case ppcle:          return "powerpcle";
-  case r600:           return "r600";
-  case renderscript32: return "renderscript32";
-  case renderscript64: return "renderscript64";
-  case riscv32:        return "riscv32";
-  case riscv64:        return "riscv64";
-  case shave:          return "shave";
-  case sparc:          return "sparc";
-  case sparcel:        return "sparcel";
-  case sparcv9:        return "sparcv9";
-  case spir64:         return "spir64";
-  case spir:           return "spir";
-  case systemz:        return "s390x";
-  case tce:            return "tce";
-  case tcele:          return "tcele";
-  case thumb:          return "thumb";
-  case thumbeb:        return "thumbeb";
-  case ve:             return "ve";
-  case wasm32:         return "wasm32";
-  case wasm64:         return "wasm64";
-  case x86:            return "i386";
-  case x86_64:         return "x86_64";
-  case xcore:          return "xcore";
-  }
-
-  llvm_unreachable("Invalid ArchType!");
-}
-
-StringRef Triple::getArchTypePrefix(ArchType Kind) {
-  switch (Kind) {
-  default:
-    return StringRef();
-
-  case aarch64:
-  case aarch64_be:
-  case aarch64_32:  return "aarch64";
-
-  case arc:         return "arc";
-
-  case arm:
-  case armeb:
-  case thumb:
-  case thumbeb:     return "arm";
-
-  case avr:         return "avr";
-
-  case ppc64:
-  case ppc64le:
+  case r600:           return "r600"; 
+  case renderscript32: return "renderscript32"; 
+  case renderscript64: return "renderscript64"; 
+  case riscv32:        return "riscv32"; 
+  case riscv64:        return "riscv64"; 
+  case shave:          return "shave"; 
+  case sparc:          return "sparc"; 
+  case sparcel:        return "sparcel"; 
+  case sparcv9:        return "sparcv9"; 
+  case spir64:         return "spir64"; 
+  case spir:           return "spir"; 
+  case systemz:        return "s390x"; 
+  case tce:            return "tce"; 
+  case tcele:          return "tcele"; 
+  case thumb:          return "thumb"; 
+  case thumbeb:        return "thumbeb"; 
+  case ve:             return "ve"; 
+  case wasm32:         return "wasm32"; 
+  case wasm64:         return "wasm64"; 
+  case x86:            return "i386"; 
+  case x86_64:         return "x86_64"; 
+  case xcore:          return "xcore"; 
+  } 
+ 
+  llvm_unreachable("Invalid ArchType!"); 
+} 
+ 
+StringRef Triple::getArchTypePrefix(ArchType Kind) { 
+  switch (Kind) { 
+  default: 
+    return StringRef(); 
+ 
+  case aarch64: 
+  case aarch64_be: 
+  case aarch64_32:  return "aarch64"; 
+ 
+  case arc:         return "arc"; 
+ 
+  case arm: 
+  case armeb: 
+  case thumb: 
+  case thumbeb:     return "arm"; 
+ 
+  case avr:         return "avr"; 
+ 
+  case ppc64: 
+  case ppc64le: 
   case ppc:
   case ppcle:       return "ppc";
-
-  case mips:
-  case mipsel:
-  case mips64:
-  case mips64el:    return "mips";
-
-  case hexagon:     return "hexagon";
-
-  case amdgcn:      return "amdgcn";
-  case r600:        return "r600";
-
-  case bpfel:
-  case bpfeb:       return "bpf";
-
-  case sparcv9:
-  case sparcel:
-  case sparc:       return "sparc";
-
-  case systemz:     return "s390";
-
-  case x86:
-  case x86_64:      return "x86";
-
-  case xcore:       return "xcore";
-
-  // NVPTX intrinsics are namespaced under nvvm.
-  case nvptx:       return "nvvm";
-  case nvptx64:     return "nvvm";
-
-  case le32:        return "le32";
-  case le64:        return "le64";
-
-  case amdil:
-  case amdil64:     return "amdil";
-
-  case hsail:
-  case hsail64:     return "hsail";
-
-  case spir:
-  case spir64:      return "spir";
-  case kalimba:     return "kalimba";
-  case lanai:       return "lanai";
-  case shave:       return "shave";
-  case wasm32:
-  case wasm64:      return "wasm";
-
-  case riscv32:
-  case riscv64:     return "riscv";
-
-  case ve:          return "ve";
+ 
+  case mips: 
+  case mipsel: 
+  case mips64: 
+  case mips64el:    return "mips"; 
+ 
+  case hexagon:     return "hexagon"; 
+ 
+  case amdgcn:      return "amdgcn"; 
+  case r600:        return "r600"; 
+ 
+  case bpfel: 
+  case bpfeb:       return "bpf"; 
+ 
+  case sparcv9: 
+  case sparcel: 
+  case sparc:       return "sparc"; 
+ 
+  case systemz:     return "s390"; 
+ 
+  case x86: 
+  case x86_64:      return "x86"; 
+ 
+  case xcore:       return "xcore"; 
+ 
+  // NVPTX intrinsics are namespaced under nvvm. 
+  case nvptx:       return "nvvm"; 
+  case nvptx64:     return "nvvm"; 
+ 
+  case le32:        return "le32"; 
+  case le64:        return "le64"; 
+ 
+  case amdil: 
+  case amdil64:     return "amdil"; 
+ 
+  case hsail: 
+  case hsail64:     return "hsail"; 
+ 
+  case spir: 
+  case spir64:      return "spir"; 
+  case kalimba:     return "kalimba"; 
+  case lanai:       return "lanai"; 
+  case shave:       return "shave"; 
+  case wasm32: 
+  case wasm64:      return "wasm"; 
+ 
+  case riscv32: 
+  case riscv64:     return "riscv"; 
+ 
+  case ve:          return "ve"; 
   case csky:        return "csky";
-  }
-}
-
-StringRef Triple::getVendorTypeName(VendorType Kind) {
-  switch (Kind) {
-  case UnknownVendor: return "unknown";
-
-  case AMD: return "amd";
-  case Apple: return "apple";
-  case CSR: return "csr";
-  case Freescale: return "fsl";
-  case IBM: return "ibm";
-  case ImaginationTechnologies: return "img";
-  case Mesa: return "mesa";
-  case MipsTechnologies: return "mti";
-  case Myriad: return "myriad";
-  case NVIDIA: return "nvidia";
-  case OpenEmbedded: return "oe";
-  case PC: return "pc";
-  case SCEI: return "scei";
-  case SUSE: return "suse";
-  }
-
-  llvm_unreachable("Invalid VendorType!");
-}
-
-StringRef Triple::getOSTypeName(OSType Kind) {
-  switch (Kind) {
-  case UnknownOS: return "unknown";
-
-  case AIX: return "aix";
-  case AMDHSA: return "amdhsa";
-  case AMDPAL: return "amdpal";
-  case Ananas: return "ananas";
-  case CUDA: return "cuda";
-  case CloudABI: return "cloudabi";
-  case Contiki: return "contiki";
-  case Darwin: return "darwin";
-  case DragonFly: return "dragonfly";
-  case ELFIAMCU: return "elfiamcu";
-  case Emscripten: return "emscripten";
-  case FreeBSD: return "freebsd";
-  case Fuchsia: return "fuchsia";
-  case Haiku: return "haiku";
-  case HermitCore: return "hermit";
-  case Hurd: return "hurd";
-  case IOS: return "ios";
-  case KFreeBSD: return "kfreebsd";
-  case Linux: return "linux";
-  case Lv2: return "lv2";
-  case MacOSX: return "macosx";
-  case Mesa3D: return "mesa3d";
-  case Minix: return "minix";
-  case NVCL: return "nvcl";
-  case NaCl: return "nacl";
-  case NetBSD: return "netbsd";
-  case OpenBSD: return "openbsd";
-  case PS4: return "ps4";
-  case RTEMS: return "rtems";
-  case Solaris: return "solaris";
-  case TvOS: return "tvos";
-  case WASI: return "wasi";
-  case WatchOS: return "watchos";
-  case Win32: return "windows";
+  } 
+} 
+ 
+StringRef Triple::getVendorTypeName(VendorType Kind) { 
+  switch (Kind) { 
+  case UnknownVendor: return "unknown"; 
+ 
+  case AMD: return "amd"; 
+  case Apple: return "apple"; 
+  case CSR: return "csr"; 
+  case Freescale: return "fsl"; 
+  case IBM: return "ibm"; 
+  case ImaginationTechnologies: return "img"; 
+  case Mesa: return "mesa"; 
+  case MipsTechnologies: return "mti"; 
+  case Myriad: return "myriad"; 
+  case NVIDIA: return "nvidia"; 
+  case OpenEmbedded: return "oe"; 
+  case PC: return "pc"; 
+  case SCEI: return "scei"; 
+  case SUSE: return "suse"; 
+  } 
+ 
+  llvm_unreachable("Invalid VendorType!"); 
+} 
+ 
+StringRef Triple::getOSTypeName(OSType Kind) { 
+  switch (Kind) { 
+  case UnknownOS: return "unknown"; 
+ 
+  case AIX: return "aix"; 
+  case AMDHSA: return "amdhsa"; 
+  case AMDPAL: return "amdpal"; 
+  case Ananas: return "ananas"; 
+  case CUDA: return "cuda"; 
+  case CloudABI: return "cloudabi"; 
+  case Contiki: return "contiki"; 
+  case Darwin: return "darwin"; 
+  case DragonFly: return "dragonfly"; 
+  case ELFIAMCU: return "elfiamcu"; 
+  case Emscripten: return "emscripten"; 
+  case FreeBSD: return "freebsd"; 
+  case Fuchsia: return "fuchsia"; 
+  case Haiku: return "haiku"; 
+  case HermitCore: return "hermit"; 
+  case Hurd: return "hurd"; 
+  case IOS: return "ios"; 
+  case KFreeBSD: return "kfreebsd"; 
+  case Linux: return "linux"; 
+  case Lv2: return "lv2"; 
+  case MacOSX: return "macosx"; 
+  case Mesa3D: return "mesa3d"; 
+  case Minix: return "minix"; 
+  case NVCL: return "nvcl"; 
+  case NaCl: return "nacl"; 
+  case NetBSD: return "netbsd"; 
+  case OpenBSD: return "openbsd"; 
+  case PS4: return "ps4"; 
+  case RTEMS: return "rtems"; 
+  case Solaris: return "solaris"; 
+  case TvOS: return "tvos"; 
+  case WASI: return "wasi"; 
+  case WatchOS: return "watchos"; 
+  case Win32: return "windows"; 
   case ZOS: return "zos";
-  }
-
-  llvm_unreachable("Invalid OSType");
-}
-
-StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
-  switch (Kind) {
-  case UnknownEnvironment: return "unknown";
-  case Android: return "android";
-  case CODE16: return "code16";
-  case CoreCLR: return "coreclr";
-  case Cygnus: return "cygnus";
-  case EABI: return "eabi";
-  case EABIHF: return "eabihf";
-  case GNU: return "gnu";
-  case GNUABI64: return "gnuabi64";
-  case GNUABIN32: return "gnuabin32";
-  case GNUEABI: return "gnueabi";
-  case GNUEABIHF: return "gnueabihf";
-  case GNUX32: return "gnux32";
+  } 
+ 
+  llvm_unreachable("Invalid OSType"); 
+} 
+ 
+StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) { 
+  switch (Kind) { 
+  case UnknownEnvironment: return "unknown"; 
+  case Android: return "android"; 
+  case CODE16: return "code16"; 
+  case CoreCLR: return "coreclr"; 
+  case Cygnus: return "cygnus"; 
+  case EABI: return "eabi"; 
+  case EABIHF: return "eabihf"; 
+  case GNU: return "gnu"; 
+  case GNUABI64: return "gnuabi64"; 
+  case GNUABIN32: return "gnuabin32"; 
+  case GNUEABI: return "gnueabi"; 
+  case GNUEABIHF: return "gnueabihf"; 
+  case GNUX32: return "gnux32"; 
   case GNUILP32: return "gnu_ilp32";
-  case Itanium: return "itanium";
-  case MSVC: return "msvc";
-  case MacABI: return "macabi";
-  case Musl: return "musl";
-  case MuslEABI: return "musleabi";
-  case MuslEABIHF: return "musleabihf";
-  case Simulator: return "simulator";
-  }
-
-  llvm_unreachable("Invalid EnvironmentType!");
-}
-
-static Triple::ArchType parseBPFArch(StringRef ArchName) {
-  if (ArchName.equals("bpf")) {
-    if (sys::IsLittleEndianHost)
-      return Triple::bpfel;
-    else
-      return Triple::bpfeb;
-  } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
-    return Triple::bpfeb;
-  } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
-    return Triple::bpfel;
-  } else {
-    return Triple::UnknownArch;
-  }
-}
-
-Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
-  Triple::ArchType BPFArch(parseBPFArch(Name));
-  return StringSwitch<Triple::ArchType>(Name)
-    .Case("aarch64", aarch64)
-    .Case("aarch64_be", aarch64_be)
-    .Case("aarch64_32", aarch64_32)
-    .Case("arc", arc)
-    .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
-    .Case("arm64_32", aarch64_32)
-    .Case("arm", arm)
-    .Case("armeb", armeb)
-    .Case("avr", avr)
-    .StartsWith("bpf", BPFArch)
-    .Case("mips", mips)
-    .Case("mipsel", mipsel)
-    .Case("mips64", mips64)
-    .Case("mips64el", mips64el)
-    .Case("msp430", msp430)
-    .Case("ppc64", ppc64)
-    .Case("ppc32", ppc)
-    .Case("ppc", ppc)
+  case Itanium: return "itanium"; 
+  case MSVC: return "msvc"; 
+  case MacABI: return "macabi"; 
+  case Musl: return "musl"; 
+  case MuslEABI: return "musleabi"; 
+  case MuslEABIHF: return "musleabihf"; 
+  case Simulator: return "simulator"; 
+  } 
+ 
+  llvm_unreachable("Invalid EnvironmentType!"); 
+} 
+ 
+static Triple::ArchType parseBPFArch(StringRef ArchName) { 
+  if (ArchName.equals("bpf")) { 
+    if (sys::IsLittleEndianHost) 
+      return Triple::bpfel; 
+    else 
+      return Triple::bpfeb; 
+  } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) { 
+    return Triple::bpfeb; 
+  } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) { 
+    return Triple::bpfel; 
+  } else { 
+    return Triple::UnknownArch; 
+  } 
+} 
+ 
+Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) { 
+  Triple::ArchType BPFArch(parseBPFArch(Name)); 
+  return StringSwitch<Triple::ArchType>(Name) 
+    .Case("aarch64", aarch64) 
+    .Case("aarch64_be", aarch64_be) 
+    .Case("aarch64_32", aarch64_32) 
+    .Case("arc", arc) 
+    .Case("arm64", aarch64) // "arm64" is an alias for "aarch64" 
+    .Case("arm64_32", aarch64_32) 
+    .Case("arm", arm) 
+    .Case("armeb", armeb) 
+    .Case("avr", avr) 
+    .StartsWith("bpf", BPFArch) 
+    .Case("mips", mips) 
+    .Case("mipsel", mipsel) 
+    .Case("mips64", mips64) 
+    .Case("mips64el", mips64el) 
+    .Case("msp430", msp430) 
+    .Case("ppc64", ppc64) 
+    .Case("ppc32", ppc) 
+    .Case("ppc", ppc) 
     .Case("ppc32le", ppcle)
     .Case("ppcle", ppcle)
-    .Case("ppc64le", ppc64le)
-    .Case("r600", r600)
-    .Case("amdgcn", amdgcn)
-    .Case("riscv32", riscv32)
-    .Case("riscv64", riscv64)
-    .Case("hexagon", hexagon)
-    .Case("sparc", sparc)
-    .Case("sparcel", sparcel)
-    .Case("sparcv9", sparcv9)
-    .Case("systemz", systemz)
-    .Case("tce", tce)
-    .Case("tcele", tcele)
-    .Case("thumb", thumb)
-    .Case("thumbeb", thumbeb)
-    .Case("x86", x86)
-    .Case("x86-64", x86_64)
-    .Case("xcore", xcore)
-    .Case("nvptx", nvptx)
-    .Case("nvptx64", nvptx64)
-    .Case("le32", le32)
-    .Case("le64", le64)
-    .Case("amdil", amdil)
-    .Case("amdil64", amdil64)
-    .Case("hsail", hsail)
-    .Case("hsail64", hsail64)
-    .Case("spir", spir)
-    .Case("spir64", spir64)
-    .Case("kalimba", kalimba)
-    .Case("lanai", lanai)
-    .Case("shave", shave)
-    .Case("wasm32", wasm32)
-    .Case("wasm64", wasm64)
-    .Case("renderscript32", renderscript32)
-    .Case("renderscript64", renderscript64)
-    .Case("ve", ve)
+    .Case("ppc64le", ppc64le) 
+    .Case("r600", r600) 
+    .Case("amdgcn", amdgcn) 
+    .Case("riscv32", riscv32) 
+    .Case("riscv64", riscv64) 
+    .Case("hexagon", hexagon) 
+    .Case("sparc", sparc) 
+    .Case("sparcel", sparcel) 
+    .Case("sparcv9", sparcv9) 
+    .Case("systemz", systemz) 
+    .Case("tce", tce) 
+    .Case("tcele", tcele) 
+    .Case("thumb", thumb) 
+    .Case("thumbeb", thumbeb) 
+    .Case("x86", x86) 
+    .Case("x86-64", x86_64) 
+    .Case("xcore", xcore) 
+    .Case("nvptx", nvptx) 
+    .Case("nvptx64", nvptx64) 
+    .Case("le32", le32) 
+    .Case("le64", le64) 
+    .Case("amdil", amdil) 
+    .Case("amdil64", amdil64) 
+    .Case("hsail", hsail) 
+    .Case("hsail64", hsail64) 
+    .Case("spir", spir) 
+    .Case("spir64", spir64) 
+    .Case("kalimba", kalimba) 
+    .Case("lanai", lanai) 
+    .Case("shave", shave) 
+    .Case("wasm32", wasm32) 
+    .Case("wasm64", wasm64) 
+    .Case("renderscript32", renderscript32) 
+    .Case("renderscript64", renderscript64) 
+    .Case("ve", ve) 
     .Case("csky", csky)
-    .Default(UnknownArch);
-}
-
-static Triple::ArchType parseARMArch(StringRef ArchName) {
-  ARM::ISAKind ISA = ARM::parseArchISA(ArchName);
-  ARM::EndianKind ENDIAN = ARM::parseArchEndian(ArchName);
-
-  Triple::ArchType arch = Triple::UnknownArch;
-  switch (ENDIAN) {
-  case ARM::EndianKind::LITTLE: {
-    switch (ISA) {
-    case ARM::ISAKind::ARM:
-      arch = Triple::arm;
-      break;
-    case ARM::ISAKind::THUMB:
-      arch = Triple::thumb;
-      break;
-    case ARM::ISAKind::AARCH64:
-      arch = Triple::aarch64;
-      break;
-    case ARM::ISAKind::INVALID:
-      break;
-    }
-    break;
-  }
-  case ARM::EndianKind::BIG: {
-    switch (ISA) {
-    case ARM::ISAKind::ARM:
-      arch = Triple::armeb;
-      break;
-    case ARM::ISAKind::THUMB:
-      arch = Triple::thumbeb;
-      break;
-    case ARM::ISAKind::AARCH64:
-      arch = Triple::aarch64_be;
-      break;
-    case ARM::ISAKind::INVALID:
-      break;
-    }
-    break;
-  }
-  case ARM::EndianKind::INVALID: {
-    break;
-  }
-  }
-
-  ArchName = ARM::getCanonicalArchName(ArchName);
-  if (ArchName.empty())
-    return Triple::UnknownArch;
-
-  // Thumb only exists in v4+
-  if (ISA == ARM::ISAKind::THUMB &&
-      (ArchName.startswith("v2") || ArchName.startswith("v3")))
-    return Triple::UnknownArch;
-
-  // Thumb only for v6m
-  ARM::ProfileKind Profile = ARM::parseArchProfile(ArchName);
-  unsigned Version = ARM::parseArchVersion(ArchName);
-  if (Profile == ARM::ProfileKind::M && Version == 6) {
-    if (ENDIAN == ARM::EndianKind::BIG)
-      return Triple::thumbeb;
-    else
-      return Triple::thumb;
-  }
-
-  return arch;
-}
-
-static Triple::ArchType parseArch(StringRef ArchName) {
-  auto AT = StringSwitch<Triple::ArchType>(ArchName)
-    .Cases("i386", "i486", "i586", "i686", Triple::x86)
-    // FIXME: Do we need to support these?
-    .Cases("i786", "i886", "i986", Triple::x86)
-    .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
-    .Cases("powerpc", "powerpcspe", "ppc", "ppc32", Triple::ppc)
+    .Default(UnknownArch); 
+} 
+ 
+static Triple::ArchType parseARMArch(StringRef ArchName) { 
+  ARM::ISAKind ISA = ARM::parseArchISA(ArchName); 
+  ARM::EndianKind ENDIAN = ARM::parseArchEndian(ArchName); 
+ 
+  Triple::ArchType arch = Triple::UnknownArch; 
+  switch (ENDIAN) { 
+  case ARM::EndianKind::LITTLE: { 
+    switch (ISA) { 
+    case ARM::ISAKind::ARM: 
+      arch = Triple::arm; 
+      break; 
+    case ARM::ISAKind::THUMB: 
+      arch = Triple::thumb; 
+      break; 
+    case ARM::ISAKind::AARCH64: 
+      arch = Triple::aarch64; 
+      break; 
+    case ARM::ISAKind::INVALID: 
+      break; 
+    } 
+    break; 
+  } 
+  case ARM::EndianKind::BIG: { 
+    switch (ISA) { 
+    case ARM::ISAKind::ARM: 
+      arch = Triple::armeb; 
+      break; 
+    case ARM::ISAKind::THUMB: 
+      arch = Triple::thumbeb; 
+      break; 
+    case ARM::ISAKind::AARCH64: 
+      arch = Triple::aarch64_be; 
+      break; 
+    case ARM::ISAKind::INVALID: 
+      break; 
+    } 
+    break; 
+  } 
+  case ARM::EndianKind::INVALID: { 
+    break; 
+  } 
+  } 
+ 
+  ArchName = ARM::getCanonicalArchName(ArchName); 
+  if (ArchName.empty()) 
+    return Triple::UnknownArch; 
+ 
+  // Thumb only exists in v4+ 
+  if (ISA == ARM::ISAKind::THUMB && 
+      (ArchName.startswith("v2") || ArchName.startswith("v3"))) 
+    return Triple::UnknownArch; 
+ 
+  // Thumb only for v6m 
+  ARM::ProfileKind Profile = ARM::parseArchProfile(ArchName); 
+  unsigned Version = ARM::parseArchVersion(ArchName); 
+  if (Profile == ARM::ProfileKind::M && Version == 6) { 
+    if (ENDIAN == ARM::EndianKind::BIG) 
+      return Triple::thumbeb; 
+    else 
+      return Triple::thumb; 
+  } 
+ 
+  return arch; 
+} 
+ 
+static Triple::ArchType parseArch(StringRef ArchName) { 
+  auto AT = StringSwitch<Triple::ArchType>(ArchName) 
+    .Cases("i386", "i486", "i586", "i686", Triple::x86) 
+    // FIXME: Do we need to support these? 
+    .Cases("i786", "i886", "i986", Triple::x86) 
+    .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64) 
+    .Cases("powerpc", "powerpcspe", "ppc", "ppc32", Triple::ppc) 
     .Cases("powerpcle", "ppcle", "ppc32le", Triple::ppcle)
-    .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)
-    .Cases("powerpc64le", "ppc64le", Triple::ppc64le)
-    .Case("xscale", Triple::arm)
-    .Case("xscaleeb", Triple::armeb)
-    .Case("aarch64", Triple::aarch64)
-    .Case("aarch64_be", Triple::aarch64_be)
-    .Case("aarch64_32", Triple::aarch64_32)
-    .Case("arc", Triple::arc)
-    .Case("arm64", Triple::aarch64)
-    .Case("arm64_32", Triple::aarch64_32)
+    .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64) 
+    .Cases("powerpc64le", "ppc64le", Triple::ppc64le) 
+    .Case("xscale", Triple::arm) 
+    .Case("xscaleeb", Triple::armeb) 
+    .Case("aarch64", Triple::aarch64) 
+    .Case("aarch64_be", Triple::aarch64_be) 
+    .Case("aarch64_32", Triple::aarch64_32) 
+    .Case("arc", Triple::arc) 
+    .Case("arm64", Triple::aarch64) 
+    .Case("arm64_32", Triple::aarch64_32) 
     .Case("arm64e", Triple::aarch64)
-    .Case("arm", Triple::arm)
-    .Case("armeb", Triple::armeb)
-    .Case("thumb", Triple::thumb)
-    .Case("thumbeb", Triple::thumbeb)
-    .Case("avr", Triple::avr)
-    .Case("msp430", Triple::msp430)
-    .Cases("mips", "mipseb", "mipsallegrex", "mipsisa32r6",
-           "mipsr6", Triple::mips)
-    .Cases("mipsel", "mipsallegrexel", "mipsisa32r6el", "mipsr6el",
-           Triple::mipsel)
-    .Cases("mips64", "mips64eb", "mipsn32", "mipsisa64r6",
-           "mips64r6", "mipsn32r6", Triple::mips64)
-    .Cases("mips64el", "mipsn32el", "mipsisa64r6el", "mips64r6el",
-           "mipsn32r6el", Triple::mips64el)
-    .Case("r600", Triple::r600)
-    .Case("amdgcn", Triple::amdgcn)
-    .Case("riscv32", Triple::riscv32)
-    .Case("riscv64", Triple::riscv64)
-    .Case("hexagon", Triple::hexagon)
-    .Cases("s390x", "systemz", Triple::systemz)
-    .Case("sparc", Triple::sparc)
-    .Case("sparcel", Triple::sparcel)
-    .Cases("sparcv9", "sparc64", Triple::sparcv9)
-    .Case("tce", Triple::tce)
-    .Case("tcele", Triple::tcele)
-    .Case("xcore", Triple::xcore)
-    .Case("nvptx", Triple::nvptx)
-    .Case("nvptx64", Triple::nvptx64)
-    .Case("le32", Triple::le32)
-    .Case("le64", Triple::le64)
-    .Case("amdil", Triple::amdil)
-    .Case("amdil64", Triple::amdil64)
-    .Case("hsail", Triple::hsail)
-    .Case("hsail64", Triple::hsail64)
-    .Case("spir", Triple::spir)
-    .Case("spir64", Triple::spir64)
-    .StartsWith("kalimba", Triple::kalimba)
-    .Case("lanai", Triple::lanai)
-    .Case("renderscript32", Triple::renderscript32)
-    .Case("renderscript64", Triple::renderscript64)
-    .Case("shave", Triple::shave)
-    .Case("ve", Triple::ve)
-    .Case("wasm32", Triple::wasm32)
-    .Case("wasm64", Triple::wasm64)
+    .Case("arm", Triple::arm) 
+    .Case("armeb", Triple::armeb) 
+    .Case("thumb", Triple::thumb) 
+    .Case("thumbeb", Triple::thumbeb) 
+    .Case("avr", Triple::avr) 
+    .Case("msp430", Triple::msp430) 
+    .Cases("mips", "mipseb", "mipsallegrex", "mipsisa32r6", 
+           "mipsr6", Triple::mips) 
+    .Cases("mipsel", "mipsallegrexel", "mipsisa32r6el", "mipsr6el", 
+           Triple::mipsel) 
+    .Cases("mips64", "mips64eb", "mipsn32", "mipsisa64r6", 
+           "mips64r6", "mipsn32r6", Triple::mips64) 
+    .Cases("mips64el", "mipsn32el", "mipsisa64r6el", "mips64r6el", 
+           "mipsn32r6el", Triple::mips64el) 
+    .Case("r600", Triple::r600) 
+    .Case("amdgcn", Triple::amdgcn) 
+    .Case("riscv32", Triple::riscv32) 
+    .Case("riscv64", Triple::riscv64) 
+    .Case("hexagon", Triple::hexagon) 
+    .Cases("s390x", "systemz", Triple::systemz) 
+    .Case("sparc", Triple::sparc) 
+    .Case("sparcel", Triple::sparcel) 
+    .Cases("sparcv9", "sparc64", Triple::sparcv9) 
+    .Case("tce", Triple::tce) 
+    .Case("tcele", Triple::tcele) 
+    .Case("xcore", Triple::xcore) 
+    .Case("nvptx", Triple::nvptx) 
+    .Case("nvptx64", Triple::nvptx64) 
+    .Case("le32", Triple::le32) 
+    .Case("le64", Triple::le64) 
+    .Case("amdil", Triple::amdil) 
+    .Case("amdil64", Triple::amdil64) 
+    .Case("hsail", Triple::hsail) 
+    .Case("hsail64", Triple::hsail64) 
+    .Case("spir", Triple::spir) 
+    .Case("spir64", Triple::spir64) 
+    .StartsWith("kalimba", Triple::kalimba) 
+    .Case("lanai", Triple::lanai) 
+    .Case("renderscript32", Triple::renderscript32) 
+    .Case("renderscript64", Triple::renderscript64) 
+    .Case("shave", Triple::shave) 
+    .Case("ve", Triple::ve) 
+    .Case("wasm32", Triple::wasm32) 
+    .Case("wasm64", Triple::wasm64) 
     .Case("csky", Triple::csky)
-    .Default(Triple::UnknownArch);
-
-  // Some architectures require special parsing logic just to compute the
-  // ArchType result.
-  if (AT == Triple::UnknownArch) {
-    if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
-        ArchName.startswith("aarch64"))
-      return parseARMArch(ArchName);
-    if (ArchName.startswith("bpf"))
-      return parseBPFArch(ArchName);
-  }
-
-  return AT;
-}
-
-static Triple::VendorType parseVendor(StringRef VendorName) {
-  return StringSwitch<Triple::VendorType>(VendorName)
-    .Case("apple", Triple::Apple)
-    .Case("pc", Triple::PC)
-    .Case("scei", Triple::SCEI)
-    .Case("fsl", Triple::Freescale)
-    .Case("ibm", Triple::IBM)
-    .Case("img", Triple::ImaginationTechnologies)
-    .Case("mti", Triple::MipsTechnologies)
-    .Case("nvidia", Triple::NVIDIA)
-    .Case("csr", Triple::CSR)
-    .Case("myriad", Triple::Myriad)
-    .Case("amd", Triple::AMD)
-    .Case("mesa", Triple::Mesa)
-    .Case("suse", Triple::SUSE)
-    .Case("oe", Triple::OpenEmbedded)
-    .Default(Triple::UnknownVendor);
-}
-
-static Triple::OSType parseOS(StringRef OSName) {
-  return StringSwitch<Triple::OSType>(OSName)
-    .StartsWith("ananas", Triple::Ananas)
-    .StartsWith("cloudabi", Triple::CloudABI)
-    .StartsWith("darwin", Triple::Darwin)
-    .StartsWith("dragonfly", Triple::DragonFly)
-    .StartsWith("freebsd", Triple::FreeBSD)
-    .StartsWith("fuchsia", Triple::Fuchsia)
-    .StartsWith("ios", Triple::IOS)
-    .StartsWith("kfreebsd", Triple::KFreeBSD)
-    .StartsWith("linux", Triple::Linux)
-    .StartsWith("lv2", Triple::Lv2)
-    .StartsWith("macos", Triple::MacOSX)
-    .StartsWith("netbsd", Triple::NetBSD)
-    .StartsWith("openbsd", Triple::OpenBSD)
-    .StartsWith("solaris", Triple::Solaris)
-    .StartsWith("win32", Triple::Win32)
-    .StartsWith("windows", Triple::Win32)
+    .Default(Triple::UnknownArch); 
+ 
+  // Some architectures require special parsing logic just to compute the 
+  // ArchType result. 
+  if (AT == Triple::UnknownArch) { 
+    if (ArchName.startswith("arm") || ArchName.startswith("thumb") || 
+        ArchName.startswith("aarch64")) 
+      return parseARMArch(ArchName); 
+    if (ArchName.startswith("bpf")) 
+      return parseBPFArch(ArchName); 
+  } 
+ 
+  return AT; 
+} 
+ 
+static Triple::VendorType parseVendor(StringRef VendorName) { 
+  return StringSwitch<Triple::VendorType>(VendorName) 
+    .Case("apple", Triple::Apple) 
+    .Case("pc", Triple::PC) 
+    .Case("scei", Triple::SCEI) 
+    .Case("fsl", Triple::Freescale) 
+    .Case("ibm", Triple::IBM) 
+    .Case("img", Triple::ImaginationTechnologies) 
+    .Case("mti", Triple::MipsTechnologies) 
+    .Case("nvidia", Triple::NVIDIA) 
+    .Case("csr", Triple::CSR) 
+    .Case("myriad", Triple::Myriad) 
+    .Case("amd", Triple::AMD) 
+    .Case("mesa", Triple::Mesa) 
+    .Case("suse", Triple::SUSE) 
+    .Case("oe", Triple::OpenEmbedded) 
+    .Default(Triple::UnknownVendor); 
+} 
+ 
+static Triple::OSType parseOS(StringRef OSName) { 
+  return StringSwitch<Triple::OSType>(OSName) 
+    .StartsWith("ananas", Triple::Ananas) 
+    .StartsWith("cloudabi", Triple::CloudABI) 
+    .StartsWith("darwin", Triple::Darwin) 
+    .StartsWith("dragonfly", Triple::DragonFly) 
+    .StartsWith("freebsd", Triple::FreeBSD) 
+    .StartsWith("fuchsia", Triple::Fuchsia) 
+    .StartsWith("ios", Triple::IOS) 
+    .StartsWith("kfreebsd", Triple::KFreeBSD) 
+    .StartsWith("linux", Triple::Linux) 
+    .StartsWith("lv2", Triple::Lv2) 
+    .StartsWith("macos", Triple::MacOSX) 
+    .StartsWith("netbsd", Triple::NetBSD) 
+    .StartsWith("openbsd", Triple::OpenBSD) 
+    .StartsWith("solaris", Triple::Solaris) 
+    .StartsWith("win32", Triple::Win32) 
+    .StartsWith("windows", Triple::Win32) 
     .StartsWith("zos", Triple::ZOS)
-    .StartsWith("haiku", Triple::Haiku)
-    .StartsWith("minix", Triple::Minix)
-    .StartsWith("rtems", Triple::RTEMS)
-    .StartsWith("nacl", Triple::NaCl)
-    .StartsWith("aix", Triple::AIX)
-    .StartsWith("cuda", Triple::CUDA)
-    .StartsWith("nvcl", Triple::NVCL)
-    .StartsWith("amdhsa", Triple::AMDHSA)
-    .StartsWith("ps4", Triple::PS4)
-    .StartsWith("elfiamcu", Triple::ELFIAMCU)
-    .StartsWith("tvos", Triple::TvOS)
-    .StartsWith("watchos", Triple::WatchOS)
-    .StartsWith("mesa3d", Triple::Mesa3D)
-    .StartsWith("contiki", Triple::Contiki)
-    .StartsWith("amdpal", Triple::AMDPAL)
-    .StartsWith("hermit", Triple::HermitCore)
-    .StartsWith("hurd", Triple::Hurd)
-    .StartsWith("wasi", Triple::WASI)
-    .StartsWith("emscripten", Triple::Emscripten)
-    .Default(Triple::UnknownOS);
-}
-
-static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
-  return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
+    .StartsWith("haiku", Triple::Haiku) 
+    .StartsWith("minix", Triple::Minix) 
+    .StartsWith("rtems", Triple::RTEMS) 
+    .StartsWith("nacl", Triple::NaCl) 
+    .StartsWith("aix", Triple::AIX) 
+    .StartsWith("cuda", Triple::CUDA) 
+    .StartsWith("nvcl", Triple::NVCL) 
+    .StartsWith("amdhsa", Triple::AMDHSA) 
+    .StartsWith("ps4", Triple::PS4) 
+    .StartsWith("elfiamcu", Triple::ELFIAMCU) 
+    .StartsWith("tvos", Triple::TvOS) 
+    .StartsWith("watchos", Triple::WatchOS) 
+    .StartsWith("mesa3d", Triple::Mesa3D) 
+    .StartsWith("contiki", Triple::Contiki) 
+    .StartsWith("amdpal", Triple::AMDPAL) 
+    .StartsWith("hermit", Triple::HermitCore) 
+    .StartsWith("hurd", Triple::Hurd) 
+    .StartsWith("wasi", Triple::WASI) 
+    .StartsWith("emscripten", Triple::Emscripten) 
+    .Default(Triple::UnknownOS); 
+} 
+ 
+static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) { 
+  return StringSwitch<Triple::EnvironmentType>(EnvironmentName) 
       .StartsWith("eabihf", Triple::EABIHF)
       .StartsWith("eabi", Triple::EABI)
       .StartsWith("gnuabin32", Triple::GNUABIN32)
@@ -557,1208 +557,1208 @@ static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
       .StartsWith("simulator", Triple::Simulator)
       .StartsWith("macabi", Triple::MacABI)
       .Default(Triple::UnknownEnvironment);
-}
-
-static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
-  return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
-    // "xcoff" must come before "coff" because of the order-dependendent
-    // pattern matching.
-    .EndsWith("xcoff", Triple::XCOFF)
-    .EndsWith("coff", Triple::COFF)
-    .EndsWith("elf", Triple::ELF)
+} 
+ 
+static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) { 
+  return StringSwitch<Triple::ObjectFormatType>(EnvironmentName) 
+    // "xcoff" must come before "coff" because of the order-dependendent 
+    // pattern matching. 
+    .EndsWith("xcoff", Triple::XCOFF) 
+    .EndsWith("coff", Triple::COFF) 
+    .EndsWith("elf", Triple::ELF) 
     .EndsWith("goff", Triple::GOFF)
-    .EndsWith("macho", Triple::MachO)
-    .EndsWith("wasm", Triple::Wasm)
-    .Default(Triple::UnknownObjectFormat);
-}
-
-static Triple::SubArchType parseSubArch(StringRef SubArchName) {
-  if (SubArchName.startswith("mips") &&
-      (SubArchName.endswith("r6el") || SubArchName.endswith("r6")))
-    return Triple::MipsSubArch_r6;
-
-  if (SubArchName == "powerpcspe")
-    return Triple::PPCSubArch_spe;
-
+    .EndsWith("macho", Triple::MachO) 
+    .EndsWith("wasm", Triple::Wasm) 
+    .Default(Triple::UnknownObjectFormat); 
+} 
+ 
+static Triple::SubArchType parseSubArch(StringRef SubArchName) { 
+  if (SubArchName.startswith("mips") && 
+      (SubArchName.endswith("r6el") || SubArchName.endswith("r6"))) 
+    return Triple::MipsSubArch_r6; 
+ 
+  if (SubArchName == "powerpcspe") 
+    return Triple::PPCSubArch_spe; 
+ 
   if (SubArchName == "arm64e")
     return Triple::AArch64SubArch_arm64e;
 
-  StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
-
-  // For now, this is the small part. Early return.
-  if (ARMSubArch.empty())
-    return StringSwitch<Triple::SubArchType>(SubArchName)
-      .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
-      .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
-      .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
-      .Default(Triple::NoSubArch);
-
-  // ARM sub arch.
-  switch(ARM::parseArch(ARMSubArch)) {
-  case ARM::ArchKind::ARMV4:
-    return Triple::NoSubArch;
-  case ARM::ArchKind::ARMV4T:
-    return Triple::ARMSubArch_v4t;
-  case ARM::ArchKind::ARMV5T:
-    return Triple::ARMSubArch_v5;
-  case ARM::ArchKind::ARMV5TE:
-  case ARM::ArchKind::IWMMXT:
-  case ARM::ArchKind::IWMMXT2:
-  case ARM::ArchKind::XSCALE:
-  case ARM::ArchKind::ARMV5TEJ:
-    return Triple::ARMSubArch_v5te;
-  case ARM::ArchKind::ARMV6:
-    return Triple::ARMSubArch_v6;
-  case ARM::ArchKind::ARMV6K:
-  case ARM::ArchKind::ARMV6KZ:
-    return Triple::ARMSubArch_v6k;
-  case ARM::ArchKind::ARMV6T2:
-    return Triple::ARMSubArch_v6t2;
-  case ARM::ArchKind::ARMV6M:
-    return Triple::ARMSubArch_v6m;
-  case ARM::ArchKind::ARMV7A:
-  case ARM::ArchKind::ARMV7R:
-    return Triple::ARMSubArch_v7;
-  case ARM::ArchKind::ARMV7VE:
-    return Triple::ARMSubArch_v7ve;
-  case ARM::ArchKind::ARMV7K:
-    return Triple::ARMSubArch_v7k;
-  case ARM::ArchKind::ARMV7M:
-    return Triple::ARMSubArch_v7m;
-  case ARM::ArchKind::ARMV7S:
-    return Triple::ARMSubArch_v7s;
-  case ARM::ArchKind::ARMV7EM:
-    return Triple::ARMSubArch_v7em;
-  case ARM::ArchKind::ARMV8A:
-    return Triple::ARMSubArch_v8;
-  case ARM::ArchKind::ARMV8_1A:
-    return Triple::ARMSubArch_v8_1a;
-  case ARM::ArchKind::ARMV8_2A:
-    return Triple::ARMSubArch_v8_2a;
-  case ARM::ArchKind::ARMV8_3A:
-    return Triple::ARMSubArch_v8_3a;
-  case ARM::ArchKind::ARMV8_4A:
-    return Triple::ARMSubArch_v8_4a;
-  case ARM::ArchKind::ARMV8_5A:
-    return Triple::ARMSubArch_v8_5a;
-  case ARM::ArchKind::ARMV8_6A:
-    return Triple::ARMSubArch_v8_6a;
+  StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName); 
+ 
+  // For now, this is the small part. Early return. 
+  if (ARMSubArch.empty()) 
+    return StringSwitch<Triple::SubArchType>(SubArchName) 
+      .EndsWith("kalimba3", Triple::KalimbaSubArch_v3) 
+      .EndsWith("kalimba4", Triple::KalimbaSubArch_v4) 
+      .EndsWith("kalimba5", Triple::KalimbaSubArch_v5) 
+      .Default(Triple::NoSubArch); 
+ 
+  // ARM sub arch. 
+  switch(ARM::parseArch(ARMSubArch)) { 
+  case ARM::ArchKind::ARMV4: 
+    return Triple::NoSubArch; 
+  case ARM::ArchKind::ARMV4T: 
+    return Triple::ARMSubArch_v4t; 
+  case ARM::ArchKind::ARMV5T: 
+    return Triple::ARMSubArch_v5; 
+  case ARM::ArchKind::ARMV5TE: 
+  case ARM::ArchKind::IWMMXT: 
+  case ARM::ArchKind::IWMMXT2: 
+  case ARM::ArchKind::XSCALE: 
+  case ARM::ArchKind::ARMV5TEJ: 
+    return Triple::ARMSubArch_v5te; 
+  case ARM::ArchKind::ARMV6: 
+    return Triple::ARMSubArch_v6; 
+  case ARM::ArchKind::ARMV6K: 
+  case ARM::ArchKind::ARMV6KZ: 
+    return Triple::ARMSubArch_v6k; 
+  case ARM::ArchKind::ARMV6T2: 
+    return Triple::ARMSubArch_v6t2; 
+  case ARM::ArchKind::ARMV6M: 
+    return Triple::ARMSubArch_v6m; 
+  case ARM::ArchKind::ARMV7A: 
+  case ARM::ArchKind::ARMV7R: 
+    return Triple::ARMSubArch_v7; 
+  case ARM::ArchKind::ARMV7VE: 
+    return Triple::ARMSubArch_v7ve; 
+  case ARM::ArchKind::ARMV7K: 
+    return Triple::ARMSubArch_v7k; 
+  case ARM::ArchKind::ARMV7M: 
+    return Triple::ARMSubArch_v7m; 
+  case ARM::ArchKind::ARMV7S: 
+    return Triple::ARMSubArch_v7s; 
+  case ARM::ArchKind::ARMV7EM: 
+    return Triple::ARMSubArch_v7em; 
+  case ARM::ArchKind::ARMV8A: 
+    return Triple::ARMSubArch_v8; 
+  case ARM::ArchKind::ARMV8_1A: 
+    return Triple::ARMSubArch_v8_1a; 
+  case ARM::ArchKind::ARMV8_2A: 
+    return Triple::ARMSubArch_v8_2a; 
+  case ARM::ArchKind::ARMV8_3A: 
+    return Triple::ARMSubArch_v8_3a; 
+  case ARM::ArchKind::ARMV8_4A: 
+    return Triple::ARMSubArch_v8_4a; 
+  case ARM::ArchKind::ARMV8_5A: 
+    return Triple::ARMSubArch_v8_5a; 
+  case ARM::ArchKind::ARMV8_6A: 
+    return Triple::ARMSubArch_v8_6a; 
   case ARM::ArchKind::ARMV8_7A:
     return Triple::ARMSubArch_v8_7a;
-  case ARM::ArchKind::ARMV8R:
-    return Triple::ARMSubArch_v8r;
-  case ARM::ArchKind::ARMV8MBaseline:
-    return Triple::ARMSubArch_v8m_baseline;
-  case ARM::ArchKind::ARMV8MMainline:
-    return Triple::ARMSubArch_v8m_mainline;
-  case ARM::ArchKind::ARMV8_1MMainline:
-    return Triple::ARMSubArch_v8_1m_mainline;
-  default:
-    return Triple::NoSubArch;
-  }
-}
-
-static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
-  switch (Kind) {
-  case Triple::UnknownObjectFormat: return "";
-  case Triple::COFF:  return "coff";
-  case Triple::ELF:   return "elf";
+  case ARM::ArchKind::ARMV8R: 
+    return Triple::ARMSubArch_v8r; 
+  case ARM::ArchKind::ARMV8MBaseline: 
+    return Triple::ARMSubArch_v8m_baseline; 
+  case ARM::ArchKind::ARMV8MMainline: 
+    return Triple::ARMSubArch_v8m_mainline; 
+  case ARM::ArchKind::ARMV8_1MMainline: 
+    return Triple::ARMSubArch_v8_1m_mainline; 
+  default: 
+    return Triple::NoSubArch; 
+  } 
+} 
+ 
+static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) { 
+  switch (Kind) { 
+  case Triple::UnknownObjectFormat: return ""; 
+  case Triple::COFF:  return "coff"; 
+  case Triple::ELF:   return "elf"; 
   case Triple::GOFF:  return "goff";
-  case Triple::MachO: return "macho";
-  case Triple::Wasm:  return "wasm";
-  case Triple::XCOFF: return "xcoff";
-  }
-  llvm_unreachable("unknown object format type");
-}
-
-static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
-  switch (T.getArch()) {
-  case Triple::UnknownArch:
-  case Triple::aarch64:
-  case Triple::aarch64_32:
-  case Triple::arm:
-  case Triple::thumb:
-  case Triple::x86:
-  case Triple::x86_64:
-    if (T.isOSDarwin())
-      return Triple::MachO;
-    else if (T.isOSWindows())
-      return Triple::COFF;
-    return Triple::ELF;
-
-  case Triple::aarch64_be:
-  case Triple::amdgcn:
-  case Triple::amdil64:
-  case Triple::amdil:
-  case Triple::arc:
-  case Triple::armeb:
-  case Triple::avr:
-  case Triple::bpfeb:
-  case Triple::bpfel:
+  case Triple::MachO: return "macho"; 
+  case Triple::Wasm:  return "wasm"; 
+  case Triple::XCOFF: return "xcoff"; 
+  } 
+  llvm_unreachable("unknown object format type"); 
+} 
+ 
+static Triple::ObjectFormatType getDefaultFormat(const Triple &T) { 
+  switch (T.getArch()) { 
+  case Triple::UnknownArch: 
+  case Triple::aarch64: 
+  case Triple::aarch64_32: 
+  case Triple::arm: 
+  case Triple::thumb: 
+  case Triple::x86: 
+  case Triple::x86_64: 
+    if (T.isOSDarwin()) 
+      return Triple::MachO; 
+    else if (T.isOSWindows()) 
+      return Triple::COFF; 
+    return Triple::ELF; 
+ 
+  case Triple::aarch64_be: 
+  case Triple::amdgcn: 
+  case Triple::amdil64: 
+  case Triple::amdil: 
+  case Triple::arc: 
+  case Triple::armeb: 
+  case Triple::avr: 
+  case Triple::bpfeb: 
+  case Triple::bpfel: 
   case Triple::csky:
-  case Triple::hexagon:
-  case Triple::hsail64:
-  case Triple::hsail:
-  case Triple::kalimba:
-  case Triple::lanai:
-  case Triple::le32:
-  case Triple::le64:
-  case Triple::mips64:
-  case Triple::mips64el:
-  case Triple::mips:
-  case Triple::mipsel:
-  case Triple::msp430:
-  case Triple::nvptx64:
-  case Triple::nvptx:
-  case Triple::ppc64le:
+  case Triple::hexagon: 
+  case Triple::hsail64: 
+  case Triple::hsail: 
+  case Triple::kalimba: 
+  case Triple::lanai: 
+  case Triple::le32: 
+  case Triple::le64: 
+  case Triple::mips64: 
+  case Triple::mips64el: 
+  case Triple::mips: 
+  case Triple::mipsel: 
+  case Triple::msp430: 
+  case Triple::nvptx64: 
+  case Triple::nvptx: 
+  case Triple::ppc64le: 
   case Triple::ppcle:
-  case Triple::r600:
-  case Triple::renderscript32:
-  case Triple::renderscript64:
-  case Triple::riscv32:
-  case Triple::riscv64:
-  case Triple::shave:
-  case Triple::sparc:
-  case Triple::sparcel:
-  case Triple::sparcv9:
-  case Triple::spir64:
-  case Triple::spir:
-  case Triple::tce:
-  case Triple::tcele:
-  case Triple::thumbeb:
-  case Triple::ve:
-  case Triple::xcore:
-    return Triple::ELF;
-
-  case Triple::ppc64:
-  case Triple::ppc:
-    if (T.isOSAIX())
-      return Triple::XCOFF;
-    return Triple::ELF;
-
+  case Triple::r600: 
+  case Triple::renderscript32: 
+  case Triple::renderscript64: 
+  case Triple::riscv32: 
+  case Triple::riscv64: 
+  case Triple::shave: 
+  case Triple::sparc: 
+  case Triple::sparcel: 
+  case Triple::sparcv9: 
+  case Triple::spir64: 
+  case Triple::spir: 
+  case Triple::tce: 
+  case Triple::tcele: 
+  case Triple::thumbeb: 
+  case Triple::ve: 
+  case Triple::xcore: 
+    return Triple::ELF; 
+ 
+  case Triple::ppc64: 
+  case Triple::ppc: 
+    if (T.isOSAIX()) 
+      return Triple::XCOFF; 
+    return Triple::ELF; 
+ 
   case Triple::systemz:
     if (T.isOSzOS())
       return Triple::GOFF;
     return Triple::ELF;
 
-  case Triple::wasm32:
-  case Triple::wasm64:
-    return Triple::Wasm;
-  }
-  llvm_unreachable("unknown architecture");
-}
-
-/// Construct a triple from the string representation provided.
-///
-/// This stores the string representation and parses the various pieces into
-/// enum members.
-Triple::Triple(const Twine &Str)
-    : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
-      Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
-      ObjectFormat(UnknownObjectFormat) {
-  // Do minimal parsing by hand here.
-  SmallVector<StringRef, 4> Components;
-  StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
-  if (Components.size() > 0) {
-    Arch = parseArch(Components[0]);
-    SubArch = parseSubArch(Components[0]);
-    if (Components.size() > 1) {
-      Vendor = parseVendor(Components[1]);
-      if (Components.size() > 2) {
-        OS = parseOS(Components[2]);
-        if (Components.size() > 3) {
-          Environment = parseEnvironment(Components[3]);
-          ObjectFormat = parseFormat(Components[3]);
-        }
-      }
-    } else {
-      Environment =
-          StringSwitch<Triple::EnvironmentType>(Components[0])
-              .StartsWith("mipsn32", Triple::GNUABIN32)
-              .StartsWith("mips64", Triple::GNUABI64)
-              .StartsWith("mipsisa64", Triple::GNUABI64)
-              .StartsWith("mipsisa32", Triple::GNU)
-              .Cases("mips", "mipsel", "mipsr6", "mipsr6el", Triple::GNU)
-              .Default(UnknownEnvironment);
-    }
-  }
-  if (ObjectFormat == UnknownObjectFormat)
-    ObjectFormat = getDefaultFormat(*this);
-}
-
-/// Construct a triple from string representations of the architecture,
-/// vendor, and OS.
-///
-/// This joins each argument into a canonical string representation and parses
-/// them into enum members. It leaves the environment unknown and omits it from
-/// the string representation.
-Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
-    : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
-      Arch(parseArch(ArchStr.str())),
-      SubArch(parseSubArch(ArchStr.str())),
-      Vendor(parseVendor(VendorStr.str())),
-      OS(parseOS(OSStr.str())),
-      Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
-  ObjectFormat = getDefaultFormat(*this);
-}
-
-/// Construct a triple from string representations of the architecture,
-/// vendor, OS, and environment.
-///
-/// This joins each argument into a canonical string representation and parses
-/// them into enum members.
-Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
-               const Twine &EnvironmentStr)
-    : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
-            EnvironmentStr).str()),
-      Arch(parseArch(ArchStr.str())),
-      SubArch(parseSubArch(ArchStr.str())),
-      Vendor(parseVendor(VendorStr.str())),
-      OS(parseOS(OSStr.str())),
-      Environment(parseEnvironment(EnvironmentStr.str())),
-      ObjectFormat(parseFormat(EnvironmentStr.str())) {
-  if (ObjectFormat == Triple::UnknownObjectFormat)
-    ObjectFormat = getDefaultFormat(*this);
-}
-
-std::string Triple::normalize(StringRef Str) {
-  bool IsMinGW32 = false;
-  bool IsCygwin = false;
-
-  // Parse into components.
-  SmallVector<StringRef, 4> Components;
-  Str.split(Components, '-');
-
-  // If the first component corresponds to a known architecture, preferentially
-  // use it for the architecture.  If the second component corresponds to a
-  // known vendor, preferentially use it for the vendor, etc.  This avoids silly
-  // component movement when a component parses as (eg) both a valid arch and a
-  // valid os.
-  ArchType Arch = UnknownArch;
-  if (Components.size() > 0)
-    Arch = parseArch(Components[0]);
-  VendorType Vendor = UnknownVendor;
-  if (Components.size() > 1)
-    Vendor = parseVendor(Components[1]);
-  OSType OS = UnknownOS;
-  if (Components.size() > 2) {
-    OS = parseOS(Components[2]);
-    IsCygwin = Components[2].startswith("cygwin");
-    IsMinGW32 = Components[2].startswith("mingw");
-  }
-  EnvironmentType Environment = UnknownEnvironment;
-  if (Components.size() > 3)
-    Environment = parseEnvironment(Components[3]);
-  ObjectFormatType ObjectFormat = UnknownObjectFormat;
-  if (Components.size() > 4)
-    ObjectFormat = parseFormat(Components[4]);
-
-  // Note which components are already in their final position.  These will not
-  // be moved.
-  bool Found[4];
-  Found[0] = Arch != UnknownArch;
-  Found[1] = Vendor != UnknownVendor;
-  Found[2] = OS != UnknownOS;
-  Found[3] = Environment != UnknownEnvironment;
-
-  // If they are not there already, permute the components into their canonical
-  // positions by seeing if they parse as a valid architecture, and if so moving
-  // the component to the architecture position etc.
-  for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
-    if (Found[Pos])
-      continue; // Already in the canonical position.
-
-    for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
-      // Do not reparse any components that already matched.
-      if (Idx < array_lengthof(Found) && Found[Idx])
-        continue;
-
-      // Does this component parse as valid for the target position?
-      bool Valid = false;
-      StringRef Comp = Components[Idx];
-      switch (Pos) {
-      default: llvm_unreachable("unexpected component type!");
-      case 0:
-        Arch = parseArch(Comp);
-        Valid = Arch != UnknownArch;
-        break;
-      case 1:
-        Vendor = parseVendor(Comp);
-        Valid = Vendor != UnknownVendor;
-        break;
-      case 2:
-        OS = parseOS(Comp);
-        IsCygwin = Comp.startswith("cygwin");
-        IsMinGW32 = Comp.startswith("mingw");
-        Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
-        break;
-      case 3:
-        Environment = parseEnvironment(Comp);
-        Valid = Environment != UnknownEnvironment;
-        if (!Valid) {
-          ObjectFormat = parseFormat(Comp);
-          Valid = ObjectFormat != UnknownObjectFormat;
-        }
-        break;
-      }
-      if (!Valid)
-        continue; // Nope, try the next component.
-
-      // Move the component to the target position, pushing any non-fixed
-      // components that are in the way to the right.  This tends to give
-      // good results in the common cases of a forgotten vendor component
-      // or a wrongly positioned environment.
-      if (Pos < Idx) {
-        // Insert left, pushing the existing components to the right.  For
-        // example, a-b-i386 -> i386-a-b when moving i386 to the front.
-        StringRef CurrentComponent(""); // The empty component.
-        // Replace the component we are moving with an empty component.
-        std::swap(CurrentComponent, Components[Idx]);
-        // Insert the component being moved at Pos, displacing any existing
-        // components to the right.
-        for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
-          // Skip over any fixed components.
-          while (i < array_lengthof(Found) && Found[i])
-            ++i;
-          // Place the component at the new position, getting the component
-          // that was at this position - it will be moved right.
-          std::swap(CurrentComponent, Components[i]);
-        }
-      } else if (Pos > Idx) {
-        // Push right by inserting empty components until the component at Idx
-        // reaches the target position Pos.  For example, pc-a -> -pc-a when
-        // moving pc to the second position.
-        do {
-          // Insert one empty component at Idx.
-          StringRef CurrentComponent(""); // The empty component.
-          for (unsigned i = Idx; i < Components.size();) {
-            // Place the component at the new position, getting the component
-            // that was at this position - it will be moved right.
-            std::swap(CurrentComponent, Components[i]);
-            // If it was placed on top of an empty component then we are done.
-            if (CurrentComponent.empty())
-              break;
-            // Advance to the next component, skipping any fixed components.
-            while (++i < array_lengthof(Found) && Found[i])
-              ;
-          }
-          // The last component was pushed off the end - append it.
-          if (!CurrentComponent.empty())
-            Components.push_back(CurrentComponent);
-
-          // Advance Idx to the component's new position.
-          while (++Idx < array_lengthof(Found) && Found[Idx])
-            ;
-        } while (Idx < Pos); // Add more until the final position is reached.
-      }
-      assert(Pos < Components.size() && Components[Pos] == Comp &&
-             "Component moved wrong!");
-      Found[Pos] = true;
-      break;
-    }
-  }
-
-  // Replace empty components with "unknown" value.
-  for (unsigned i = 0, e = Components.size(); i < e; ++i) {
-    if (Components[i].empty())
-      Components[i] = "unknown";
-  }
-
-  // Special case logic goes here.  At this point Arch, Vendor and OS have the
-  // correct values for the computed components.
-  std::string NormalizedEnvironment;
-  if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
-    StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
-    if (AndroidVersion.empty()) {
-      Components[3] = "android";
-    } else {
-      NormalizedEnvironment = Twine("android", AndroidVersion).str();
-      Components[3] = NormalizedEnvironment;
-    }
-  }
-
-  // SUSE uses "gnueabi" to mean "gnueabihf"
-  if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI)
-    Components[3] = "gnueabihf";
-
-  if (OS == Triple::Win32) {
-    Components.resize(4);
-    Components[2] = "windows";
-    if (Environment == UnknownEnvironment) {
-      if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
-        Components[3] = "msvc";
-      else
-        Components[3] = getObjectFormatTypeName(ObjectFormat);
-    }
-  } else if (IsMinGW32) {
-    Components.resize(4);
-    Components[2] = "windows";
-    Components[3] = "gnu";
-  } else if (IsCygwin) {
-    Components.resize(4);
-    Components[2] = "windows";
-    Components[3] = "cygnus";
-  }
-  if (IsMinGW32 || IsCygwin ||
-      (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
-    if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
-      Components.resize(5);
-      Components[4] = getObjectFormatTypeName(ObjectFormat);
-    }
-  }
-
-  // Stick the corrected components back together to form the normalized string.
-  return join(Components, "-");
-}
-
-StringRef Triple::getArchName() const {
-  return StringRef(Data).split('-').first;           // Isolate first component
-}
-
-StringRef Triple::getVendorName() const {
-  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
-  return Tmp.split('-').first;                       // Isolate second component
-}
-
-StringRef Triple::getOSName() const {
-  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
-  Tmp = Tmp.split('-').second;                       // Strip second component
-  return Tmp.split('-').first;                       // Isolate third component
-}
-
-StringRef Triple::getEnvironmentName() const {
-  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
-  Tmp = Tmp.split('-').second;                       // Strip second component
-  return Tmp.split('-').second;                      // Strip third component
-}
-
-StringRef Triple::getOSAndEnvironmentName() const {
-  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
-  return Tmp.split('-').second;                      // Strip second component
-}
-
-static unsigned EatNumber(StringRef &Str) {
+  case Triple::wasm32: 
+  case Triple::wasm64: 
+    return Triple::Wasm; 
+  } 
+  llvm_unreachable("unknown architecture"); 
+} 
+ 
+/// Construct a triple from the string representation provided. 
+/// 
+/// This stores the string representation and parses the various pieces into 
+/// enum members. 
+Triple::Triple(const Twine &Str) 
+    : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch), 
+      Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment), 
+      ObjectFormat(UnknownObjectFormat) { 
+  // Do minimal parsing by hand here. 
+  SmallVector<StringRef, 4> Components; 
+  StringRef(Data).split(Components, '-', /*MaxSplit*/ 3); 
+  if (Components.size() > 0) { 
+    Arch = parseArch(Components[0]); 
+    SubArch = parseSubArch(Components[0]); 
+    if (Components.size() > 1) { 
+      Vendor = parseVendor(Components[1]); 
+      if (Components.size() > 2) { 
+        OS = parseOS(Components[2]); 
+        if (Components.size() > 3) { 
+          Environment = parseEnvironment(Components[3]); 
+          ObjectFormat = parseFormat(Components[3]); 
+        } 
+      } 
+    } else { 
+      Environment = 
+          StringSwitch<Triple::EnvironmentType>(Components[0]) 
+              .StartsWith("mipsn32", Triple::GNUABIN32) 
+              .StartsWith("mips64", Triple::GNUABI64) 
+              .StartsWith("mipsisa64", Triple::GNUABI64) 
+              .StartsWith("mipsisa32", Triple::GNU) 
+              .Cases("mips", "mipsel", "mipsr6", "mipsr6el", Triple::GNU) 
+              .Default(UnknownEnvironment); 
+    } 
+  } 
+  if (ObjectFormat == UnknownObjectFormat) 
+    ObjectFormat = getDefaultFormat(*this); 
+} 
+ 
+/// Construct a triple from string representations of the architecture, 
+/// vendor, and OS. 
+/// 
+/// This joins each argument into a canonical string representation and parses 
+/// them into enum members. It leaves the environment unknown and omits it from 
+/// the string representation. 
+Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr) 
+    : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()), 
+      Arch(parseArch(ArchStr.str())), 
+      SubArch(parseSubArch(ArchStr.str())), 
+      Vendor(parseVendor(VendorStr.str())), 
+      OS(parseOS(OSStr.str())), 
+      Environment(), ObjectFormat(Triple::UnknownObjectFormat) { 
+  ObjectFormat = getDefaultFormat(*this); 
+} 
+ 
+/// Construct a triple from string representations of the architecture, 
+/// vendor, OS, and environment. 
+/// 
+/// This joins each argument into a canonical string representation and parses 
+/// them into enum members. 
+Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr, 
+               const Twine &EnvironmentStr) 
+    : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') + 
+            EnvironmentStr).str()), 
+      Arch(parseArch(ArchStr.str())), 
+      SubArch(parseSubArch(ArchStr.str())), 
+      Vendor(parseVendor(VendorStr.str())), 
+      OS(parseOS(OSStr.str())), 
+      Environment(parseEnvironment(EnvironmentStr.str())), 
+      ObjectFormat(parseFormat(EnvironmentStr.str())) { 
+  if (ObjectFormat == Triple::UnknownObjectFormat) 
+    ObjectFormat = getDefaultFormat(*this); 
+} 
+ 
+std::string Triple::normalize(StringRef Str) { 
+  bool IsMinGW32 = false; 
+  bool IsCygwin = false; 
+ 
+  // Parse into components. 
+  SmallVector<StringRef, 4> Components; 
+  Str.split(Components, '-'); 
+ 
+  // If the first component corresponds to a known architecture, preferentially 
+  // use it for the architecture.  If the second component corresponds to a 
+  // known vendor, preferentially use it for the vendor, etc.  This avoids silly 
+  // component movement when a component parses as (eg) both a valid arch and a 
+  // valid os. 
+  ArchType Arch = UnknownArch; 
+  if (Components.size() > 0) 
+    Arch = parseArch(Components[0]); 
+  VendorType Vendor = UnknownVendor; 
+  if (Components.size() > 1) 
+    Vendor = parseVendor(Components[1]); 
+  OSType OS = UnknownOS; 
+  if (Components.size() > 2) { 
+    OS = parseOS(Components[2]); 
+    IsCygwin = Components[2].startswith("cygwin"); 
+    IsMinGW32 = Components[2].startswith("mingw"); 
+  } 
+  EnvironmentType Environment = UnknownEnvironment; 
+  if (Components.size() > 3) 
+    Environment = parseEnvironment(Components[3]); 
+  ObjectFormatType ObjectFormat = UnknownObjectFormat; 
+  if (Components.size() > 4) 
+    ObjectFormat = parseFormat(Components[4]); 
+ 
+  // Note which components are already in their final position.  These will not 
+  // be moved. 
+  bool Found[4]; 
+  Found[0] = Arch != UnknownArch; 
+  Found[1] = Vendor != UnknownVendor; 
+  Found[2] = OS != UnknownOS; 
+  Found[3] = Environment != UnknownEnvironment; 
+ 
+  // If they are not there already, permute the components into their canonical 
+  // positions by seeing if they parse as a valid architecture, and if so moving 
+  // the component to the architecture position etc. 
+  for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) { 
+    if (Found[Pos]) 
+      continue; // Already in the canonical position. 
+ 
+    for (unsigned Idx = 0; Idx != Components.size(); ++Idx) { 
+      // Do not reparse any components that already matched. 
+      if (Idx < array_lengthof(Found) && Found[Idx]) 
+        continue; 
+ 
+      // Does this component parse as valid for the target position? 
+      bool Valid = false; 
+      StringRef Comp = Components[Idx]; 
+      switch (Pos) { 
+      default: llvm_unreachable("unexpected component type!"); 
+      case 0: 
+        Arch = parseArch(Comp); 
+        Valid = Arch != UnknownArch; 
+        break; 
+      case 1: 
+        Vendor = parseVendor(Comp); 
+        Valid = Vendor != UnknownVendor; 
+        break; 
+      case 2: 
+        OS = parseOS(Comp); 
+        IsCygwin = Comp.startswith("cygwin"); 
+        IsMinGW32 = Comp.startswith("mingw"); 
+        Valid = OS != UnknownOS || IsCygwin || IsMinGW32; 
+        break; 
+      case 3: 
+        Environment = parseEnvironment(Comp); 
+        Valid = Environment != UnknownEnvironment; 
+        if (!Valid) { 
+          ObjectFormat = parseFormat(Comp); 
+          Valid = ObjectFormat != UnknownObjectFormat; 
+        } 
+        break; 
+      } 
+      if (!Valid) 
+        continue; // Nope, try the next component. 
+ 
+      // Move the component to the target position, pushing any non-fixed 
+      // components that are in the way to the right.  This tends to give 
+      // good results in the common cases of a forgotten vendor component 
+      // or a wrongly positioned environment. 
+      if (Pos < Idx) { 
+        // Insert left, pushing the existing components to the right.  For 
+        // example, a-b-i386 -> i386-a-b when moving i386 to the front. 
+        StringRef CurrentComponent(""); // The empty component. 
+        // Replace the component we are moving with an empty component. 
+        std::swap(CurrentComponent, Components[Idx]); 
+        // Insert the component being moved at Pos, displacing any existing 
+        // components to the right. 
+        for (unsigned i = Pos; !CurrentComponent.empty(); ++i) { 
+          // Skip over any fixed components. 
+          while (i < array_lengthof(Found) && Found[i]) 
+            ++i; 
+          // Place the component at the new position, getting the component 
+          // that was at this position - it will be moved right. 
+          std::swap(CurrentComponent, Components[i]); 
+        } 
+      } else if (Pos > Idx) { 
+        // Push right by inserting empty components until the component at Idx 
+        // reaches the target position Pos.  For example, pc-a -> -pc-a when 
+        // moving pc to the second position. 
+        do { 
+          // Insert one empty component at Idx. 
+          StringRef CurrentComponent(""); // The empty component. 
+          for (unsigned i = Idx; i < Components.size();) { 
+            // Place the component at the new position, getting the component 
+            // that was at this position - it will be moved right. 
+            std::swap(CurrentComponent, Components[i]); 
+            // If it was placed on top of an empty component then we are done. 
+            if (CurrentComponent.empty()) 
+              break; 
+            // Advance to the next component, skipping any fixed components. 
+            while (++i < array_lengthof(Found) && Found[i]) 
+              ; 
+          } 
+          // The last component was pushed off the end - append it. 
+          if (!CurrentComponent.empty()) 
+            Components.push_back(CurrentComponent); 
+ 
+          // Advance Idx to the component's new position. 
+          while (++Idx < array_lengthof(Found) && Found[Idx]) 
+            ; 
+        } while (Idx < Pos); // Add more until the final position is reached. 
+      } 
+      assert(Pos < Components.size() && Components[Pos] == Comp && 
+             "Component moved wrong!"); 
+      Found[Pos] = true; 
+      break; 
+    } 
+  } 
+ 
+  // Replace empty components with "unknown" value. 
+  for (unsigned i = 0, e = Components.size(); i < e; ++i) { 
+    if (Components[i].empty()) 
+      Components[i] = "unknown"; 
+  } 
+ 
+  // Special case logic goes here.  At this point Arch, Vendor and OS have the 
+  // correct values for the computed components. 
+  std::string NormalizedEnvironment; 
+  if (Environment == Triple::Android && Components[3].startswith("androideabi")) { 
+    StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi")); 
+    if (AndroidVersion.empty()) { 
+      Components[3] = "android"; 
+    } else { 
+      NormalizedEnvironment = Twine("android", AndroidVersion).str(); 
+      Components[3] = NormalizedEnvironment; 
+    } 
+  } 
+ 
+  // SUSE uses "gnueabi" to mean "gnueabihf" 
+  if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI) 
+    Components[3] = "gnueabihf"; 
+ 
+  if (OS == Triple::Win32) { 
+    Components.resize(4); 
+    Components[2] = "windows"; 
+    if (Environment == UnknownEnvironment) { 
+      if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF) 
+        Components[3] = "msvc"; 
+      else 
+        Components[3] = getObjectFormatTypeName(ObjectFormat); 
+    } 
+  } else if (IsMinGW32) { 
+    Components.resize(4); 
+    Components[2] = "windows"; 
+    Components[3] = "gnu"; 
+  } else if (IsCygwin) { 
+    Components.resize(4); 
+    Components[2] = "windows"; 
+    Components[3] = "cygnus"; 
+  } 
+  if (IsMinGW32 || IsCygwin || 
+      (OS == Triple::Win32 && Environment != UnknownEnvironment)) { 
+    if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) { 
+      Components.resize(5); 
+      Components[4] = getObjectFormatTypeName(ObjectFormat); 
+    } 
+  } 
+ 
+  // Stick the corrected components back together to form the normalized string. 
+  return join(Components, "-"); 
+} 
+ 
+StringRef Triple::getArchName() const { 
+  return StringRef(Data).split('-').first;           // Isolate first component 
+} 
+ 
+StringRef Triple::getVendorName() const { 
+  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 
+  return Tmp.split('-').first;                       // Isolate second component 
+} 
+ 
+StringRef Triple::getOSName() const { 
+  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 
+  Tmp = Tmp.split('-').second;                       // Strip second component 
+  return Tmp.split('-').first;                       // Isolate third component 
+} 
+ 
+StringRef Triple::getEnvironmentName() const { 
+  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 
+  Tmp = Tmp.split('-').second;                       // Strip second component 
+  return Tmp.split('-').second;                      // Strip third component 
+} 
+ 
+StringRef Triple::getOSAndEnvironmentName() const { 
+  StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 
+  return Tmp.split('-').second;                      // Strip second component 
+} 
+ 
+static unsigned EatNumber(StringRef &Str) { 
   assert(!Str.empty() && isDigit(Str[0]) && "Not a number");
-  unsigned Result = 0;
-
-  do {
-    // Consume the leading digit.
-    Result = Result*10 + (Str[0] - '0');
-
-    // Eat the digit.
-    Str = Str.substr(1);
+  unsigned Result = 0; 
+ 
+  do { 
+    // Consume the leading digit. 
+    Result = Result*10 + (Str[0] - '0'); 
+ 
+    // Eat the digit. 
+    Str = Str.substr(1); 
   } while (!Str.empty() && isDigit(Str[0]));
-
-  return Result;
-}
-
-static void parseVersionFromName(StringRef Name, unsigned &Major,
-                                 unsigned &Minor, unsigned &Micro) {
-  // Any unset version defaults to 0.
-  Major = Minor = Micro = 0;
-
-  // Parse up to three components.
-  unsigned *Components[3] = {&Major, &Minor, &Micro};
-  for (unsigned i = 0; i != 3; ++i) {
-    if (Name.empty() || Name[0] < '0' || Name[0] > '9')
-      break;
-
-    // Consume the leading number.
-    *Components[i] = EatNumber(Name);
-
-    // Consume the separator, if present.
-    if (Name.startswith("."))
-      Name = Name.substr(1);
-  }
-}
-
-void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
-                                   unsigned &Micro) const {
-  StringRef EnvironmentName = getEnvironmentName();
-  StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
-  if (EnvironmentName.startswith(EnvironmentTypeName))
-    EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
-
-  parseVersionFromName(EnvironmentName, Major, Minor, Micro);
-}
-
-void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
-                          unsigned &Micro) const {
-  StringRef OSName = getOSName();
-  // Assume that the OS portion of the triple starts with the canonical name.
-  StringRef OSTypeName = getOSTypeName(getOS());
-  if (OSName.startswith(OSTypeName))
-    OSName = OSName.substr(OSTypeName.size());
-  else if (getOS() == MacOSX)
-    OSName.consume_front("macos");
-
-  parseVersionFromName(OSName, Major, Minor, Micro);
-}
-
-bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
-                              unsigned &Micro) const {
-  getOSVersion(Major, Minor, Micro);
-
-  switch (getOS()) {
-  default: llvm_unreachable("unexpected OS for Darwin triple");
-  case Darwin:
-    // Default to darwin8, i.e., MacOSX 10.4.
-    if (Major == 0)
-      Major = 8;
-    // Darwin version numbers are skewed from OS X versions.
-    if (Major < 4)
-      return false;
-    if (Major <= 19) {
-      Micro = 0;
-      Minor = Major - 4;
-      Major = 10;
-    } else {
-      Micro = 0;
-      Minor = 0;
-      // darwin20+ corresponds to macOS 11+.
-      Major = 11 + Major - 20;
-    }
-    break;
-  case MacOSX:
-    // Default to 10.4.
-    if (Major == 0) {
-      Major = 10;
-      Minor = 4;
-    } else if (Major < 10)
-      return false;
-    break;
-  case IOS:
-  case TvOS:
-  case WatchOS:
-    // Ignore the version from the triple.  This is only handled because the
-    // the clang driver combines OS X and IOS support into a common Darwin
-    // toolchain that wants to know the OS X version number even when targeting
-    // IOS.
-    Major = 10;
-    Minor = 4;
-    Micro = 0;
-    break;
-  }
-  return true;
-}
-
-void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
-                           unsigned &Micro) const {
-  switch (getOS()) {
-  default: llvm_unreachable("unexpected OS for Darwin triple");
-  case Darwin:
-  case MacOSX:
-    // Ignore the version from the triple.  This is only handled because the
-    // the clang driver combines OS X and IOS support into a common Darwin
-    // toolchain that wants to know the iOS version number even when targeting
-    // OS X.
-    Major = 5;
-    Minor = 0;
-    Micro = 0;
-    break;
-  case IOS:
-  case TvOS:
-    getOSVersion(Major, Minor, Micro);
-    // Default to 5.0 (or 7.0 for arm64).
-    if (Major == 0)
-      Major = (getArch() == aarch64) ? 7 : 5;
-    break;
-  case WatchOS:
-    llvm_unreachable("conflicting triple info");
-  }
-}
-
-void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
-                               unsigned &Micro) const {
-  switch (getOS()) {
-  default: llvm_unreachable("unexpected OS for Darwin triple");
-  case Darwin:
-  case MacOSX:
-    // Ignore the version from the triple.  This is only handled because the
-    // the clang driver combines OS X and IOS support into a common Darwin
-    // toolchain that wants to know the iOS version number even when targeting
-    // OS X.
-    Major = 2;
-    Minor = 0;
-    Micro = 0;
-    break;
-  case WatchOS:
-    getOSVersion(Major, Minor, Micro);
-    if (Major == 0)
-      Major = 2;
-    break;
-  case IOS:
-    llvm_unreachable("conflicting triple info");
-  }
-}
-
-void Triple::setTriple(const Twine &Str) {
-  *this = Triple(Str);
-}
-
-void Triple::setArch(ArchType Kind) {
-  setArchName(getArchTypeName(Kind));
-}
-
-void Triple::setVendor(VendorType Kind) {
-  setVendorName(getVendorTypeName(Kind));
-}
-
-void Triple::setOS(OSType Kind) {
-  setOSName(getOSTypeName(Kind));
-}
-
-void Triple::setEnvironment(EnvironmentType Kind) {
-  if (ObjectFormat == getDefaultFormat(*this))
-    return setEnvironmentName(getEnvironmentTypeName(Kind));
-
-  setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
-                      getObjectFormatTypeName(ObjectFormat)).str());
-}
-
-void Triple::setObjectFormat(ObjectFormatType Kind) {
-  if (Environment == UnknownEnvironment)
-    return setEnvironmentName(getObjectFormatTypeName(Kind));
-
-  setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
-                      getObjectFormatTypeName(Kind)).str());
-}
-
-void Triple::setArchName(StringRef Str) {
-  // Work around a miscompilation bug for Twines in gcc 4.0.3.
-  SmallString<64> Triple;
-  Triple += Str;
-  Triple += "-";
-  Triple += getVendorName();
-  Triple += "-";
-  Triple += getOSAndEnvironmentName();
-  setTriple(Triple);
-}
-
-void Triple::setVendorName(StringRef Str) {
-  setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
-}
-
-void Triple::setOSName(StringRef Str) {
-  if (hasEnvironment())
-    setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
-              "-" + getEnvironmentName());
-  else
-    setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
-}
-
-void Triple::setEnvironmentName(StringRef Str) {
-  setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
-            "-" + Str);
-}
-
-void Triple::setOSAndEnvironmentName(StringRef Str) {
-  setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
-}
-
-static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
-  switch (Arch) {
-  case llvm::Triple::UnknownArch:
-    return 0;
-
-  case llvm::Triple::avr:
-  case llvm::Triple::msp430:
-    return 16;
-
-  case llvm::Triple::aarch64_32:
-  case llvm::Triple::amdil:
-  case llvm::Triple::arc:
-  case llvm::Triple::arm:
-  case llvm::Triple::armeb:
+ 
+  return Result; 
+} 
+ 
+static void parseVersionFromName(StringRef Name, unsigned &Major, 
+                                 unsigned &Minor, unsigned &Micro) { 
+  // Any unset version defaults to 0. 
+  Major = Minor = Micro = 0; 
+ 
+  // Parse up to three components. 
+  unsigned *Components[3] = {&Major, &Minor, &Micro}; 
+  for (unsigned i = 0; i != 3; ++i) { 
+    if (Name.empty() || Name[0] < '0' || Name[0] > '9') 
+      break; 
+ 
+    // Consume the leading number. 
+    *Components[i] = EatNumber(Name); 
+ 
+    // Consume the separator, if present. 
+    if (Name.startswith(".")) 
+      Name = Name.substr(1); 
+  } 
+} 
+ 
+void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor, 
+                                   unsigned &Micro) const { 
+  StringRef EnvironmentName = getEnvironmentName(); 
+  StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment()); 
+  if (EnvironmentName.startswith(EnvironmentTypeName)) 
+    EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size()); 
+ 
+  parseVersionFromName(EnvironmentName, Major, Minor, Micro); 
+} 
+ 
+void Triple::getOSVersion(unsigned &Major, unsigned &Minor, 
+                          unsigned &Micro) const { 
+  StringRef OSName = getOSName(); 
+  // Assume that the OS portion of the triple starts with the canonical name. 
+  StringRef OSTypeName = getOSTypeName(getOS()); 
+  if (OSName.startswith(OSTypeName)) 
+    OSName = OSName.substr(OSTypeName.size()); 
+  else if (getOS() == MacOSX) 
+    OSName.consume_front("macos"); 
+ 
+  parseVersionFromName(OSName, Major, Minor, Micro); 
+} 
+ 
+bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor, 
+                              unsigned &Micro) const { 
+  getOSVersion(Major, Minor, Micro); 
+ 
+  switch (getOS()) { 
+  default: llvm_unreachable("unexpected OS for Darwin triple"); 
+  case Darwin: 
+    // Default to darwin8, i.e., MacOSX 10.4. 
+    if (Major == 0) 
+      Major = 8; 
+    // Darwin version numbers are skewed from OS X versions. 
+    if (Major < 4) 
+      return false; 
+    if (Major <= 19) { 
+      Micro = 0; 
+      Minor = Major - 4; 
+      Major = 10; 
+    } else { 
+      Micro = 0; 
+      Minor = 0; 
+      // darwin20+ corresponds to macOS 11+. 
+      Major = 11 + Major - 20; 
+    } 
+    break; 
+  case MacOSX: 
+    // Default to 10.4. 
+    if (Major == 0) { 
+      Major = 10; 
+      Minor = 4; 
+    } else if (Major < 10) 
+      return false; 
+    break; 
+  case IOS: 
+  case TvOS: 
+  case WatchOS: 
+    // Ignore the version from the triple.  This is only handled because the 
+    // the clang driver combines OS X and IOS support into a common Darwin 
+    // toolchain that wants to know the OS X version number even when targeting 
+    // IOS. 
+    Major = 10; 
+    Minor = 4; 
+    Micro = 0; 
+    break; 
+  } 
+  return true; 
+} 
+ 
+void Triple::getiOSVersion(unsigned &Major, unsigned &Minor, 
+                           unsigned &Micro) const { 
+  switch (getOS()) { 
+  default: llvm_unreachable("unexpected OS for Darwin triple"); 
+  case Darwin: 
+  case MacOSX: 
+    // Ignore the version from the triple.  This is only handled because the 
+    // the clang driver combines OS X and IOS support into a common Darwin 
+    // toolchain that wants to know the iOS version number even when targeting 
+    // OS X. 
+    Major = 5; 
+    Minor = 0; 
+    Micro = 0; 
+    break; 
+  case IOS: 
+  case TvOS: 
+    getOSVersion(Major, Minor, Micro); 
+    // Default to 5.0 (or 7.0 for arm64). 
+    if (Major == 0) 
+      Major = (getArch() == aarch64) ? 7 : 5; 
+    break; 
+  case WatchOS: 
+    llvm_unreachable("conflicting triple info"); 
+  } 
+} 
+ 
+void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor, 
+                               unsigned &Micro) const { 
+  switch (getOS()) { 
+  default: llvm_unreachable("unexpected OS for Darwin triple"); 
+  case Darwin: 
+  case MacOSX: 
+    // Ignore the version from the triple.  This is only handled because the 
+    // the clang driver combines OS X and IOS support into a common Darwin 
+    // toolchain that wants to know the iOS version number even when targeting 
+    // OS X. 
+    Major = 2; 
+    Minor = 0; 
+    Micro = 0; 
+    break; 
+  case WatchOS: 
+    getOSVersion(Major, Minor, Micro); 
+    if (Major == 0) 
+      Major = 2; 
+    break; 
+  case IOS: 
+    llvm_unreachable("conflicting triple info"); 
+  } 
+} 
+ 
+void Triple::setTriple(const Twine &Str) { 
+  *this = Triple(Str); 
+} 
+ 
+void Triple::setArch(ArchType Kind) { 
+  setArchName(getArchTypeName(Kind)); 
+} 
+ 
+void Triple::setVendor(VendorType Kind) { 
+  setVendorName(getVendorTypeName(Kind)); 
+} 
+ 
+void Triple::setOS(OSType Kind) { 
+  setOSName(getOSTypeName(Kind)); 
+} 
+ 
+void Triple::setEnvironment(EnvironmentType Kind) { 
+  if (ObjectFormat == getDefaultFormat(*this)) 
+    return setEnvironmentName(getEnvironmentTypeName(Kind)); 
+ 
+  setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") + 
+                      getObjectFormatTypeName(ObjectFormat)).str()); 
+} 
+ 
+void Triple::setObjectFormat(ObjectFormatType Kind) { 
+  if (Environment == UnknownEnvironment) 
+    return setEnvironmentName(getObjectFormatTypeName(Kind)); 
+ 
+  setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") + 
+                      getObjectFormatTypeName(Kind)).str()); 
+} 
+ 
+void Triple::setArchName(StringRef Str) { 
+  // Work around a miscompilation bug for Twines in gcc 4.0.3. 
+  SmallString<64> Triple; 
+  Triple += Str; 
+  Triple += "-"; 
+  Triple += getVendorName(); 
+  Triple += "-"; 
+  Triple += getOSAndEnvironmentName(); 
+  setTriple(Triple); 
+} 
+ 
+void Triple::setVendorName(StringRef Str) { 
+  setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName()); 
+} 
+ 
+void Triple::setOSName(StringRef Str) { 
+  if (hasEnvironment()) 
+    setTriple(getArchName() + "-" + getVendorName() + "-" + Str + 
+              "-" + getEnvironmentName()); 
+  else 
+    setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 
+} 
+ 
+void Triple::setEnvironmentName(StringRef Str) { 
+  setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() + 
+            "-" + Str); 
+} 
+ 
+void Triple::setOSAndEnvironmentName(StringRef Str) { 
+  setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 
+} 
+ 
+static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) { 
+  switch (Arch) { 
+  case llvm::Triple::UnknownArch: 
+    return 0; 
+ 
+  case llvm::Triple::avr: 
+  case llvm::Triple::msp430: 
+    return 16; 
+ 
+  case llvm::Triple::aarch64_32: 
+  case llvm::Triple::amdil: 
+  case llvm::Triple::arc: 
+  case llvm::Triple::arm: 
+  case llvm::Triple::armeb: 
   case llvm::Triple::csky:
-  case llvm::Triple::hexagon:
-  case llvm::Triple::hsail:
-  case llvm::Triple::kalimba:
-  case llvm::Triple::lanai:
-  case llvm::Triple::le32:
-  case llvm::Triple::mips:
-  case llvm::Triple::mipsel:
-  case llvm::Triple::nvptx:
-  case llvm::Triple::ppc:
+  case llvm::Triple::hexagon: 
+  case llvm::Triple::hsail: 
+  case llvm::Triple::kalimba: 
+  case llvm::Triple::lanai: 
+  case llvm::Triple::le32: 
+  case llvm::Triple::mips: 
+  case llvm::Triple::mipsel: 
+  case llvm::Triple::nvptx: 
+  case llvm::Triple::ppc: 
   case llvm::Triple::ppcle:
-  case llvm::Triple::r600:
-  case llvm::Triple::renderscript32:
-  case llvm::Triple::riscv32:
-  case llvm::Triple::shave:
-  case llvm::Triple::sparc:
-  case llvm::Triple::sparcel:
-  case llvm::Triple::spir:
-  case llvm::Triple::tce:
-  case llvm::Triple::tcele:
-  case llvm::Triple::thumb:
-  case llvm::Triple::thumbeb:
-  case llvm::Triple::wasm32:
-  case llvm::Triple::x86:
-  case llvm::Triple::xcore:
-    return 32;
-
-  case llvm::Triple::aarch64:
-  case llvm::Triple::aarch64_be:
-  case llvm::Triple::amdgcn:
-  case llvm::Triple::amdil64:
-  case llvm::Triple::bpfeb:
-  case llvm::Triple::bpfel:
-  case llvm::Triple::hsail64:
-  case llvm::Triple::le64:
-  case llvm::Triple::mips64:
-  case llvm::Triple::mips64el:
-  case llvm::Triple::nvptx64:
-  case llvm::Triple::ppc64:
-  case llvm::Triple::ppc64le:
-  case llvm::Triple::renderscript64:
-  case llvm::Triple::riscv64:
-  case llvm::Triple::sparcv9:
-  case llvm::Triple::spir64:
-  case llvm::Triple::systemz:
-  case llvm::Triple::ve:
-  case llvm::Triple::wasm64:
-  case llvm::Triple::x86_64:
-    return 64;
-  }
-  llvm_unreachable("Invalid architecture value");
-}
-
-bool Triple::isArch64Bit() const {
-  return getArchPointerBitWidth(getArch()) == 64;
-}
-
-bool Triple::isArch32Bit() const {
-  return getArchPointerBitWidth(getArch()) == 32;
-}
-
-bool Triple::isArch16Bit() const {
-  return getArchPointerBitWidth(getArch()) == 16;
-}
-
-Triple Triple::get32BitArchVariant() const {
-  Triple T(*this);
-  switch (getArch()) {
-  case Triple::UnknownArch:
-  case Triple::amdgcn:
-  case Triple::avr:
-  case Triple::bpfeb:
-  case Triple::bpfel:
-  case Triple::msp430:
-  case Triple::systemz:
-  case Triple::ve:
-    T.setArch(UnknownArch);
-    break;
-
-  case Triple::aarch64_32:
-  case Triple::amdil:
-  case Triple::arc:
-  case Triple::arm:
-  case Triple::armeb:
+  case llvm::Triple::r600: 
+  case llvm::Triple::renderscript32: 
+  case llvm::Triple::riscv32: 
+  case llvm::Triple::shave: 
+  case llvm::Triple::sparc: 
+  case llvm::Triple::sparcel: 
+  case llvm::Triple::spir: 
+  case llvm::Triple::tce: 
+  case llvm::Triple::tcele: 
+  case llvm::Triple::thumb: 
+  case llvm::Triple::thumbeb: 
+  case llvm::Triple::wasm32: 
+  case llvm::Triple::x86: 
+  case llvm::Triple::xcore: 
+    return 32; 
+ 
+  case llvm::Triple::aarch64: 
+  case llvm::Triple::aarch64_be: 
+  case llvm::Triple::amdgcn: 
+  case llvm::Triple::amdil64: 
+  case llvm::Triple::bpfeb: 
+  case llvm::Triple::bpfel: 
+  case llvm::Triple::hsail64: 
+  case llvm::Triple::le64: 
+  case llvm::Triple::mips64: 
+  case llvm::Triple::mips64el: 
+  case llvm::Triple::nvptx64: 
+  case llvm::Triple::ppc64: 
+  case llvm::Triple::ppc64le: 
+  case llvm::Triple::renderscript64: 
+  case llvm::Triple::riscv64: 
+  case llvm::Triple::sparcv9: 
+  case llvm::Triple::spir64: 
+  case llvm::Triple::systemz: 
+  case llvm::Triple::ve: 
+  case llvm::Triple::wasm64: 
+  case llvm::Triple::x86_64: 
+    return 64; 
+  } 
+  llvm_unreachable("Invalid architecture value"); 
+} 
+ 
+bool Triple::isArch64Bit() const { 
+  return getArchPointerBitWidth(getArch()) == 64; 
+} 
+ 
+bool Triple::isArch32Bit() const { 
+  return getArchPointerBitWidth(getArch()) == 32; 
+} 
+ 
+bool Triple::isArch16Bit() const { 
+  return getArchPointerBitWidth(getArch()) == 16; 
+} 
+ 
+Triple Triple::get32BitArchVariant() const { 
+  Triple T(*this); 
+  switch (getArch()) { 
+  case Triple::UnknownArch: 
+  case Triple::amdgcn: 
+  case Triple::avr: 
+  case Triple::bpfeb: 
+  case Triple::bpfel: 
+  case Triple::msp430: 
+  case Triple::systemz: 
+  case Triple::ve: 
+    T.setArch(UnknownArch); 
+    break; 
+ 
+  case Triple::aarch64_32: 
+  case Triple::amdil: 
+  case Triple::arc: 
+  case Triple::arm: 
+  case Triple::armeb: 
   case Triple::csky:
-  case Triple::hexagon:
-  case Triple::hsail:
-  case Triple::kalimba:
-  case Triple::lanai:
-  case Triple::le32:
-  case Triple::mips:
-  case Triple::mipsel:
-  case Triple::nvptx:
-  case Triple::ppc:
+  case Triple::hexagon: 
+  case Triple::hsail: 
+  case Triple::kalimba: 
+  case Triple::lanai: 
+  case Triple::le32: 
+  case Triple::mips: 
+  case Triple::mipsel: 
+  case Triple::nvptx: 
+  case Triple::ppc: 
   case Triple::ppcle:
-  case Triple::r600:
-  case Triple::renderscript32:
-  case Triple::riscv32:
-  case Triple::shave:
-  case Triple::sparc:
-  case Triple::sparcel:
-  case Triple::spir:
-  case Triple::tce:
-  case Triple::tcele:
-  case Triple::thumb:
-  case Triple::thumbeb:
-  case Triple::wasm32:
-  case Triple::x86:
-  case Triple::xcore:
-    // Already 32-bit.
-    break;
-
-  case Triple::aarch64:        T.setArch(Triple::arm);     break;
-  case Triple::aarch64_be:     T.setArch(Triple::armeb);   break;
-  case Triple::amdil64:        T.setArch(Triple::amdil);   break;
-  case Triple::hsail64:        T.setArch(Triple::hsail);   break;
-  case Triple::le64:           T.setArch(Triple::le32);    break;
-  case Triple::mips64:         T.setArch(Triple::mips);    break;
-  case Triple::mips64el:       T.setArch(Triple::mipsel);  break;
-  case Triple::nvptx64:        T.setArch(Triple::nvptx);   break;
-  case Triple::ppc64:          T.setArch(Triple::ppc);     break;
+  case Triple::r600: 
+  case Triple::renderscript32: 
+  case Triple::riscv32: 
+  case Triple::shave: 
+  case Triple::sparc: 
+  case Triple::sparcel: 
+  case Triple::spir: 
+  case Triple::tce: 
+  case Triple::tcele: 
+  case Triple::thumb: 
+  case Triple::thumbeb: 
+  case Triple::wasm32: 
+  case Triple::x86: 
+  case Triple::xcore: 
+    // Already 32-bit. 
+    break; 
+ 
+  case Triple::aarch64:        T.setArch(Triple::arm);     break; 
+  case Triple::aarch64_be:     T.setArch(Triple::armeb);   break; 
+  case Triple::amdil64:        T.setArch(Triple::amdil);   break; 
+  case Triple::hsail64:        T.setArch(Triple::hsail);   break; 
+  case Triple::le64:           T.setArch(Triple::le32);    break; 
+  case Triple::mips64:         T.setArch(Triple::mips);    break; 
+  case Triple::mips64el:       T.setArch(Triple::mipsel);  break; 
+  case Triple::nvptx64:        T.setArch(Triple::nvptx);   break; 
+  case Triple::ppc64:          T.setArch(Triple::ppc);     break; 
   case Triple::ppc64le:        T.setArch(Triple::ppcle);   break;
-  case Triple::renderscript64: T.setArch(Triple::renderscript32); break;
-  case Triple::riscv64:        T.setArch(Triple::riscv32); break;
-  case Triple::sparcv9:        T.setArch(Triple::sparc);   break;
-  case Triple::spir64:         T.setArch(Triple::spir);    break;
-  case Triple::wasm64:         T.setArch(Triple::wasm32);  break;
-  case Triple::x86_64:         T.setArch(Triple::x86);     break;
-  }
-  return T;
-}
-
-Triple Triple::get64BitArchVariant() const {
-  Triple T(*this);
-  switch (getArch()) {
-  case Triple::UnknownArch:
-  case Triple::arc:
-  case Triple::avr:
+  case Triple::renderscript64: T.setArch(Triple::renderscript32); break; 
+  case Triple::riscv64:        T.setArch(Triple::riscv32); break; 
+  case Triple::sparcv9:        T.setArch(Triple::sparc);   break; 
+  case Triple::spir64:         T.setArch(Triple::spir);    break; 
+  case Triple::wasm64:         T.setArch(Triple::wasm32);  break; 
+  case Triple::x86_64:         T.setArch(Triple::x86);     break; 
+  } 
+  return T; 
+} 
+ 
+Triple Triple::get64BitArchVariant() const { 
+  Triple T(*this); 
+  switch (getArch()) { 
+  case Triple::UnknownArch: 
+  case Triple::arc: 
+  case Triple::avr: 
   case Triple::csky:
-  case Triple::hexagon:
-  case Triple::kalimba:
-  case Triple::lanai:
-  case Triple::msp430:
-  case Triple::r600:
-  case Triple::shave:
-  case Triple::sparcel:
-  case Triple::tce:
-  case Triple::tcele:
-  case Triple::xcore:
-    T.setArch(UnknownArch);
-    break;
-
-  case Triple::aarch64:
-  case Triple::aarch64_be:
-  case Triple::amdgcn:
-  case Triple::amdil64:
-  case Triple::bpfeb:
-  case Triple::bpfel:
-  case Triple::hsail64:
-  case Triple::le64:
-  case Triple::mips64:
-  case Triple::mips64el:
-  case Triple::nvptx64:
-  case Triple::ppc64:
-  case Triple::ppc64le:
-  case Triple::renderscript64:
-  case Triple::riscv64:
-  case Triple::sparcv9:
-  case Triple::spir64:
-  case Triple::systemz:
-  case Triple::ve:
-  case Triple::wasm64:
-  case Triple::x86_64:
-    // Already 64-bit.
-    break;
-
-  case Triple::aarch64_32:      T.setArch(Triple::aarch64);    break;
-  case Triple::amdil:           T.setArch(Triple::amdil64);    break;
-  case Triple::arm:             T.setArch(Triple::aarch64);    break;
-  case Triple::armeb:           T.setArch(Triple::aarch64_be); break;
-  case Triple::hsail:           T.setArch(Triple::hsail64);    break;
-  case Triple::le32:            T.setArch(Triple::le64);       break;
-  case Triple::mips:            T.setArch(Triple::mips64);     break;
-  case Triple::mipsel:          T.setArch(Triple::mips64el);   break;
-  case Triple::nvptx:           T.setArch(Triple::nvptx64);    break;
-  case Triple::ppc:             T.setArch(Triple::ppc64);      break;
+  case Triple::hexagon: 
+  case Triple::kalimba: 
+  case Triple::lanai: 
+  case Triple::msp430: 
+  case Triple::r600: 
+  case Triple::shave: 
+  case Triple::sparcel: 
+  case Triple::tce: 
+  case Triple::tcele: 
+  case Triple::xcore: 
+    T.setArch(UnknownArch); 
+    break; 
+ 
+  case Triple::aarch64: 
+  case Triple::aarch64_be: 
+  case Triple::amdgcn: 
+  case Triple::amdil64: 
+  case Triple::bpfeb: 
+  case Triple::bpfel: 
+  case Triple::hsail64: 
+  case Triple::le64: 
+  case Triple::mips64: 
+  case Triple::mips64el: 
+  case Triple::nvptx64: 
+  case Triple::ppc64: 
+  case Triple::ppc64le: 
+  case Triple::renderscript64: 
+  case Triple::riscv64: 
+  case Triple::sparcv9: 
+  case Triple::spir64: 
+  case Triple::systemz: 
+  case Triple::ve: 
+  case Triple::wasm64: 
+  case Triple::x86_64: 
+    // Already 64-bit. 
+    break; 
+ 
+  case Triple::aarch64_32:      T.setArch(Triple::aarch64);    break; 
+  case Triple::amdil:           T.setArch(Triple::amdil64);    break; 
+  case Triple::arm:             T.setArch(Triple::aarch64);    break; 
+  case Triple::armeb:           T.setArch(Triple::aarch64_be); break; 
+  case Triple::hsail:           T.setArch(Triple::hsail64);    break; 
+  case Triple::le32:            T.setArch(Triple::le64);       break; 
+  case Triple::mips:            T.setArch(Triple::mips64);     break; 
+  case Triple::mipsel:          T.setArch(Triple::mips64el);   break; 
+  case Triple::nvptx:           T.setArch(Triple::nvptx64);    break; 
+  case Triple::ppc:             T.setArch(Triple::ppc64);      break; 
   case Triple::ppcle:           T.setArch(Triple::ppc64le);    break;
-  case Triple::renderscript32:  T.setArch(Triple::renderscript64);     break;
-  case Triple::riscv32:         T.setArch(Triple::riscv64);    break;
-  case Triple::sparc:           T.setArch(Triple::sparcv9);    break;
-  case Triple::spir:            T.setArch(Triple::spir64);     break;
-  case Triple::thumb:           T.setArch(Triple::aarch64);    break;
-  case Triple::thumbeb:         T.setArch(Triple::aarch64_be); break;
-  case Triple::wasm32:          T.setArch(Triple::wasm64);     break;
-  case Triple::x86:             T.setArch(Triple::x86_64);     break;
-  }
-  return T;
-}
-
-Triple Triple::getBigEndianArchVariant() const {
-  Triple T(*this);
-  // Already big endian.
-  if (!isLittleEndian())
-    return T;
-  switch (getArch()) {
-  case Triple::UnknownArch:
-  case Triple::amdgcn:
-  case Triple::amdil64:
-  case Triple::amdil:
-  case Triple::avr:
-  case Triple::hexagon:
-  case Triple::hsail64:
-  case Triple::hsail:
-  case Triple::kalimba:
-  case Triple::le32:
-  case Triple::le64:
-  case Triple::msp430:
-  case Triple::nvptx64:
-  case Triple::nvptx:
-  case Triple::r600:
-  case Triple::renderscript32:
-  case Triple::renderscript64:
-  case Triple::riscv32:
-  case Triple::riscv64:
-  case Triple::shave:
-  case Triple::spir64:
-  case Triple::spir:
-  case Triple::wasm32:
-  case Triple::wasm64:
-  case Triple::x86:
-  case Triple::x86_64:
-  case Triple::xcore:
-  case Triple::ve:
+  case Triple::renderscript32:  T.setArch(Triple::renderscript64);     break; 
+  case Triple::riscv32:         T.setArch(Triple::riscv64);    break; 
+  case Triple::sparc:           T.setArch(Triple::sparcv9);    break; 
+  case Triple::spir:            T.setArch(Triple::spir64);     break; 
+  case Triple::thumb:           T.setArch(Triple::aarch64);    break; 
+  case Triple::thumbeb:         T.setArch(Triple::aarch64_be); break; 
+  case Triple::wasm32:          T.setArch(Triple::wasm64);     break; 
+  case Triple::x86:             T.setArch(Triple::x86_64);     break; 
+  } 
+  return T; 
+} 
+ 
+Triple Triple::getBigEndianArchVariant() const { 
+  Triple T(*this); 
+  // Already big endian. 
+  if (!isLittleEndian()) 
+    return T; 
+  switch (getArch()) { 
+  case Triple::UnknownArch: 
+  case Triple::amdgcn: 
+  case Triple::amdil64: 
+  case Triple::amdil: 
+  case Triple::avr: 
+  case Triple::hexagon: 
+  case Triple::hsail64: 
+  case Triple::hsail: 
+  case Triple::kalimba: 
+  case Triple::le32: 
+  case Triple::le64: 
+  case Triple::msp430: 
+  case Triple::nvptx64: 
+  case Triple::nvptx: 
+  case Triple::r600: 
+  case Triple::renderscript32: 
+  case Triple::renderscript64: 
+  case Triple::riscv32: 
+  case Triple::riscv64: 
+  case Triple::shave: 
+  case Triple::spir64: 
+  case Triple::spir: 
+  case Triple::wasm32: 
+  case Triple::wasm64: 
+  case Triple::x86: 
+  case Triple::x86_64: 
+  case Triple::xcore: 
+  case Triple::ve: 
   case Triple::csky:
-
-  // ARM is intentionally unsupported here, changing the architecture would
-  // drop any arch suffixes.
-  case Triple::arm:
-  case Triple::thumb:
-    T.setArch(UnknownArch);
-    break;
-
-  case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
-  case Triple::bpfel:   T.setArch(Triple::bpfeb);      break;
-  case Triple::mips64el:T.setArch(Triple::mips64);     break;
-  case Triple::mipsel:  T.setArch(Triple::mips);       break;
+ 
+  // ARM is intentionally unsupported here, changing the architecture would 
+  // drop any arch suffixes. 
+  case Triple::arm: 
+  case Triple::thumb: 
+    T.setArch(UnknownArch); 
+    break; 
+ 
+  case Triple::aarch64: T.setArch(Triple::aarch64_be); break; 
+  case Triple::bpfel:   T.setArch(Triple::bpfeb);      break; 
+  case Triple::mips64el:T.setArch(Triple::mips64);     break; 
+  case Triple::mipsel:  T.setArch(Triple::mips);       break; 
   case Triple::ppcle:   T.setArch(Triple::ppc);        break;
-  case Triple::ppc64le: T.setArch(Triple::ppc64);      break;
-  case Triple::sparcel: T.setArch(Triple::sparc);      break;
-  case Triple::tcele:   T.setArch(Triple::tce);        break;
-  default:
-    llvm_unreachable("getBigEndianArchVariant: unknown triple.");
-  }
-  return T;
-}
-
-Triple Triple::getLittleEndianArchVariant() const {
-  Triple T(*this);
-  if (isLittleEndian())
-    return T;
-
-  switch (getArch()) {
-  case Triple::UnknownArch:
-  case Triple::lanai:
-  case Triple::sparcv9:
-  case Triple::systemz:
-
-  // ARM is intentionally unsupported here, changing the architecture would
-  // drop any arch suffixes.
-  case Triple::armeb:
-  case Triple::thumbeb:
-    T.setArch(UnknownArch);
-    break;
-
-  case Triple::aarch64_be: T.setArch(Triple::aarch64);  break;
-  case Triple::bpfeb:      T.setArch(Triple::bpfel);    break;
-  case Triple::mips64:     T.setArch(Triple::mips64el); break;
-  case Triple::mips:       T.setArch(Triple::mipsel);   break;
+  case Triple::ppc64le: T.setArch(Triple::ppc64);      break; 
+  case Triple::sparcel: T.setArch(Triple::sparc);      break; 
+  case Triple::tcele:   T.setArch(Triple::tce);        break; 
+  default: 
+    llvm_unreachable("getBigEndianArchVariant: unknown triple."); 
+  } 
+  return T; 
+} 
+ 
+Triple Triple::getLittleEndianArchVariant() const { 
+  Triple T(*this); 
+  if (isLittleEndian()) 
+    return T; 
+ 
+  switch (getArch()) { 
+  case Triple::UnknownArch: 
+  case Triple::lanai: 
+  case Triple::sparcv9: 
+  case Triple::systemz: 
+ 
+  // ARM is intentionally unsupported here, changing the architecture would 
+  // drop any arch suffixes. 
+  case Triple::armeb: 
+  case Triple::thumbeb: 
+    T.setArch(UnknownArch); 
+    break; 
+ 
+  case Triple::aarch64_be: T.setArch(Triple::aarch64);  break; 
+  case Triple::bpfeb:      T.setArch(Triple::bpfel);    break; 
+  case Triple::mips64:     T.setArch(Triple::mips64el); break; 
+  case Triple::mips:       T.setArch(Triple::mipsel);   break; 
   case Triple::ppc:        T.setArch(Triple::ppcle);    break;
-  case Triple::ppc64:      T.setArch(Triple::ppc64le);  break;
-  case Triple::sparc:      T.setArch(Triple::sparcel);  break;
-  case Triple::tce:        T.setArch(Triple::tcele);    break;
-  default:
-    llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
-  }
-  return T;
-}
-
-bool Triple::isLittleEndian() const {
-  switch (getArch()) {
-  case Triple::aarch64:
-  case Triple::aarch64_32:
-  case Triple::amdgcn:
-  case Triple::amdil64:
-  case Triple::amdil:
-  case Triple::arm:
-  case Triple::avr:
-  case Triple::bpfel:
+  case Triple::ppc64:      T.setArch(Triple::ppc64le);  break; 
+  case Triple::sparc:      T.setArch(Triple::sparcel);  break; 
+  case Triple::tce:        T.setArch(Triple::tcele);    break; 
+  default: 
+    llvm_unreachable("getLittleEndianArchVariant: unknown triple."); 
+  } 
+  return T; 
+} 
+ 
+bool Triple::isLittleEndian() const { 
+  switch (getArch()) { 
+  case Triple::aarch64: 
+  case Triple::aarch64_32: 
+  case Triple::amdgcn: 
+  case Triple::amdil64: 
+  case Triple::amdil: 
+  case Triple::arm: 
+  case Triple::avr: 
+  case Triple::bpfel: 
   case Triple::csky:
-  case Triple::hexagon:
-  case Triple::hsail64:
-  case Triple::hsail:
-  case Triple::kalimba:
-  case Triple::le32:
-  case Triple::le64:
-  case Triple::mips64el:
-  case Triple::mipsel:
-  case Triple::msp430:
-  case Triple::nvptx64:
-  case Triple::nvptx:
+  case Triple::hexagon: 
+  case Triple::hsail64: 
+  case Triple::hsail: 
+  case Triple::kalimba: 
+  case Triple::le32: 
+  case Triple::le64: 
+  case Triple::mips64el: 
+  case Triple::mipsel: 
+  case Triple::msp430: 
+  case Triple::nvptx64: 
+  case Triple::nvptx: 
   case Triple::ppcle:
-  case Triple::ppc64le:
-  case Triple::r600:
-  case Triple::renderscript32:
-  case Triple::renderscript64:
-  case Triple::riscv32:
-  case Triple::riscv64:
-  case Triple::shave:
-  case Triple::sparcel:
-  case Triple::spir64:
-  case Triple::spir:
-  case Triple::tcele:
-  case Triple::thumb:
-  case Triple::ve:
-  case Triple::wasm32:
-  case Triple::wasm64:
-  case Triple::x86:
-  case Triple::x86_64:
-  case Triple::xcore:
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool Triple::isCompatibleWith(const Triple &Other) const {
-  // ARM and Thumb triples are compatible, if subarch, vendor and OS match.
-  if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) ||
-      (getArch() == Triple::arm && Other.getArch() == Triple::thumb) ||
-      (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) ||
-      (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) {
-    if (getVendor() == Triple::Apple)
-      return getSubArch() == Other.getSubArch() &&
-             getVendor() == Other.getVendor() && getOS() == Other.getOS();
-    else
-      return getSubArch() == Other.getSubArch() &&
-             getVendor() == Other.getVendor() && getOS() == Other.getOS() &&
-             getEnvironment() == Other.getEnvironment() &&
-             getObjectFormat() == Other.getObjectFormat();
-  }
-
-  // If vendor is apple, ignore the version number.
-  if (getVendor() == Triple::Apple)
-    return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
-           getVendor() == Other.getVendor() && getOS() == Other.getOS();
-
-  return *this == Other;
-}
-
-std::string Triple::merge(const Triple &Other) const {
-  // If vendor is apple, pick the triple with the larger version number.
-  if (getVendor() == Triple::Apple)
-    if (Other.isOSVersionLT(*this))
-      return str();
-
-  return Other.str();
-}
-
-bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor,
-                               unsigned Micro) const {
-  assert(isMacOSX() && "Not an OS X triple!");
-
-  // If this is OS X, expect a sane version number.
-  if (getOS() == Triple::MacOSX)
-    return isOSVersionLT(Major, Minor, Micro);
-
-  // Otherwise, compare to the "Darwin" number.
-  if (Major == 10) {
-    return isOSVersionLT(Minor + 4, Micro, 0);
-  } else {
-    assert(Major >= 11 && "Unexpected major version");
-    return isOSVersionLT(Major - 11 + 20, Minor, Micro);
-  }
-}
-
-VersionTuple Triple::getMinimumSupportedOSVersion() const {
-  if (getVendor() != Triple::Apple || getArch() != Triple::aarch64)
-    return VersionTuple();
-  switch (getOS()) {
-  case Triple::MacOSX:
-    // ARM64 slice is supported starting from macOS 11.0+.
-    return VersionTuple(11, 0, 0);
-  case Triple::IOS:
-    // ARM64 slice is supported starting from Mac Catalyst 14 (macOS 11).
-    // ARM64 simulators are supported for iOS 14+.
-    if (isMacCatalystEnvironment() || isSimulatorEnvironment())
-      return VersionTuple(14, 0, 0);
+  case Triple::ppc64le: 
+  case Triple::r600: 
+  case Triple::renderscript32: 
+  case Triple::renderscript64: 
+  case Triple::riscv32: 
+  case Triple::riscv64: 
+  case Triple::shave: 
+  case Triple::sparcel: 
+  case Triple::spir64: 
+  case Triple::spir: 
+  case Triple::tcele: 
+  case Triple::thumb: 
+  case Triple::ve: 
+  case Triple::wasm32: 
+  case Triple::wasm64: 
+  case Triple::x86: 
+  case Triple::x86_64: 
+  case Triple::xcore: 
+    return true; 
+  default: 
+    return false; 
+  } 
+} 
+ 
+bool Triple::isCompatibleWith(const Triple &Other) const { 
+  // ARM and Thumb triples are compatible, if subarch, vendor and OS match. 
+  if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) || 
+      (getArch() == Triple::arm && Other.getArch() == Triple::thumb) || 
+      (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) || 
+      (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) { 
+    if (getVendor() == Triple::Apple) 
+      return getSubArch() == Other.getSubArch() && 
+             getVendor() == Other.getVendor() && getOS() == Other.getOS(); 
+    else 
+      return getSubArch() == Other.getSubArch() && 
+             getVendor() == Other.getVendor() && getOS() == Other.getOS() && 
+             getEnvironment() == Other.getEnvironment() && 
+             getObjectFormat() == Other.getObjectFormat(); 
+  } 
+ 
+  // If vendor is apple, ignore the version number. 
+  if (getVendor() == Triple::Apple) 
+    return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() && 
+           getVendor() == Other.getVendor() && getOS() == Other.getOS(); 
+ 
+  return *this == Other; 
+} 
+ 
+std::string Triple::merge(const Triple &Other) const { 
+  // If vendor is apple, pick the triple with the larger version number. 
+  if (getVendor() == Triple::Apple) 
+    if (Other.isOSVersionLT(*this)) 
+      return str(); 
+ 
+  return Other.str(); 
+} 
+ 
+bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor, 
+                               unsigned Micro) const { 
+  assert(isMacOSX() && "Not an OS X triple!"); 
+ 
+  // If this is OS X, expect a sane version number. 
+  if (getOS() == Triple::MacOSX) 
+    return isOSVersionLT(Major, Minor, Micro); 
+ 
+  // Otherwise, compare to the "Darwin" number. 
+  if (Major == 10) { 
+    return isOSVersionLT(Minor + 4, Micro, 0); 
+  } else { 
+    assert(Major >= 11 && "Unexpected major version"); 
+    return isOSVersionLT(Major - 11 + 20, Minor, Micro); 
+  } 
+} 
+ 
+VersionTuple Triple::getMinimumSupportedOSVersion() const { 
+  if (getVendor() != Triple::Apple || getArch() != Triple::aarch64) 
+    return VersionTuple(); 
+  switch (getOS()) { 
+  case Triple::MacOSX: 
+    // ARM64 slice is supported starting from macOS 11.0+. 
+    return VersionTuple(11, 0, 0); 
+  case Triple::IOS: 
+    // ARM64 slice is supported starting from Mac Catalyst 14 (macOS 11). 
+    // ARM64 simulators are supported for iOS 14+. 
+    if (isMacCatalystEnvironment() || isSimulatorEnvironment()) 
+      return VersionTuple(14, 0, 0); 
     // ARM64e slice is supported starting from iOS 14.
     if (isArm64e())
       return VersionTuple(14, 0, 0);
-    break;
-  case Triple::TvOS:
-    // ARM64 simulators are supported for tvOS 14+.
-    if (isSimulatorEnvironment())
-      return VersionTuple(14, 0, 0);
-    break;
-  case Triple::WatchOS:
-    // ARM64 simulators are supported for watchOS 7+.
-    if (isSimulatorEnvironment())
-      return VersionTuple(7, 0, 0);
-    break;
-  default:
-    break;
-  }
-  return VersionTuple();
-}
-
-StringRef Triple::getARMCPUForArch(StringRef MArch) const {
-  if (MArch.empty())
-    MArch = getArchName();
-  MArch = ARM::getCanonicalArchName(MArch);
-
-  // Some defaults are forced.
-  switch (getOS()) {
-  case llvm::Triple::FreeBSD:
-  case llvm::Triple::NetBSD:
-    if (!MArch.empty() && MArch == "v6")
-      return "arm1176jzf-s";
-    break;
-  case llvm::Triple::Win32:
-    // FIXME: this is invalid for WindowsCE
-    return "cortex-a9";
-  case llvm::Triple::IOS:
-  case llvm::Triple::MacOSX:
-  case llvm::Triple::TvOS:
-  case llvm::Triple::WatchOS:
-    if (MArch == "v7k")
-      return "cortex-a7";
-    break;
-  default:
-    break;
-  }
-
-  if (MArch.empty())
-    return StringRef();
-
-  StringRef CPU = ARM::getDefaultCPU(MArch);
-  if (!CPU.empty() && !CPU.equals("invalid"))
-    return CPU;
-
-  // If no specific architecture version is requested, return the minimum CPU
-  // required by the OS and environment.
-  switch (getOS()) {
-  case llvm::Triple::NetBSD:
-    switch (getEnvironment()) {
-    case llvm::Triple::EABI:
-    case llvm::Triple::EABIHF:
-    case llvm::Triple::GNUEABI:
-    case llvm::Triple::GNUEABIHF:
-      return "arm926ej-s";
-    default:
-      return "strongarm";
-    }
-  case llvm::Triple::NaCl:
-  case llvm::Triple::OpenBSD:
-    return "cortex-a8";
-  default:
-    switch (getEnvironment()) {
-    case llvm::Triple::EABIHF:
-    case llvm::Triple::GNUEABIHF:
-    case llvm::Triple::MuslEABIHF:
-      return "arm1176jzf-s";
-    default:
-      return "arm7tdmi";
-    }
-  }
-
-  llvm_unreachable("invalid arch name");
-}
-
-VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind,
-                                              const VersionTuple &Version) {
-  switch (OSKind) {
-  case MacOSX:
-    // macOS 10.16 is canonicalized to macOS 11.
-    if (Version == VersionTuple(10, 16))
-      return VersionTuple(11, 0);
-    LLVM_FALLTHROUGH;
-  default:
-    return Version;
-  }
-}
+    break; 
+  case Triple::TvOS: 
+    // ARM64 simulators are supported for tvOS 14+. 
+    if (isSimulatorEnvironment()) 
+      return VersionTuple(14, 0, 0); 
+    break; 
+  case Triple::WatchOS: 
+    // ARM64 simulators are supported for watchOS 7+. 
+    if (isSimulatorEnvironment()) 
+      return VersionTuple(7, 0, 0); 
+    break; 
+  default: 
+    break; 
+  } 
+  return VersionTuple(); 
+} 
+ 
+StringRef Triple::getARMCPUForArch(StringRef MArch) const { 
+  if (MArch.empty()) 
+    MArch = getArchName(); 
+  MArch = ARM::getCanonicalArchName(MArch); 
+ 
+  // Some defaults are forced. 
+  switch (getOS()) { 
+  case llvm::Triple::FreeBSD: 
+  case llvm::Triple::NetBSD: 
+    if (!MArch.empty() && MArch == "v6") 
+      return "arm1176jzf-s"; 
+    break; 
+  case llvm::Triple::Win32: 
+    // FIXME: this is invalid for WindowsCE 
+    return "cortex-a9"; 
+  case llvm::Triple::IOS: 
+  case llvm::Triple::MacOSX: 
+  case llvm::Triple::TvOS: 
+  case llvm::Triple::WatchOS: 
+    if (MArch == "v7k") 
+      return "cortex-a7"; 
+    break; 
+  default: 
+    break; 
+  } 
+ 
+  if (MArch.empty()) 
+    return StringRef(); 
+ 
+  StringRef CPU = ARM::getDefaultCPU(MArch); 
+  if (!CPU.empty() && !CPU.equals("invalid")) 
+    return CPU; 
+ 
+  // If no specific architecture version is requested, return the minimum CPU 
+  // required by the OS and environment. 
+  switch (getOS()) { 
+  case llvm::Triple::NetBSD: 
+    switch (getEnvironment()) { 
+    case llvm::Triple::EABI: 
+    case llvm::Triple::EABIHF: 
+    case llvm::Triple::GNUEABI: 
+    case llvm::Triple::GNUEABIHF: 
+      return "arm926ej-s"; 
+    default: 
+      return "strongarm"; 
+    } 
+  case llvm::Triple::NaCl: 
+  case llvm::Triple::OpenBSD: 
+    return "cortex-a8"; 
+  default: 
+    switch (getEnvironment()) { 
+    case llvm::Triple::EABIHF: 
+    case llvm::Triple::GNUEABIHF: 
+    case llvm::Triple::MuslEABIHF: 
+      return "arm1176jzf-s"; 
+    default: 
+      return "arm7tdmi"; 
+    } 
+  } 
+ 
+  llvm_unreachable("invalid arch name"); 
+} 
+ 
+VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind, 
+                                              const VersionTuple &Version) { 
+  switch (OSKind) { 
+  case MacOSX: 
+    // macOS 10.16 is canonicalized to macOS 11. 
+    if (Version == VersionTuple(10, 16)) 
+      return VersionTuple(11, 0); 
+    LLVM_FALLTHROUGH; 
+  default: 
+    return Version; 
+  } 
+}