[triple+llc+llvm-mc] Make triple and ABI name consistent

[atanasyan]

Summary

This patch is a reincarnation of D21467 and D22304 initially created by Daniel Sanders.

The aim of this patch is to provide ABI selected by a user to all parts of LLVM backend. It is especially important for MIPS because for this target ABI name might significantly change environment and even architecture specified by a triple.

The primary changes is introduced by this patch are new ABI specific for MIPS target and new Triple:: getABIVariant method. This method accepts ABI name and makes the triple and the ABI consistent.

Using only MCTargetOptions::ABIName as a source of ABI selected by a user has some significant drawbacks for MIPS and is likely to lead to further problems down the line.

One of the drawbacks is that to enable IAS by default for N64 we need to make MCTargetOptions available to MipsMCAsmInfo which requires changing both the public C++ API and the public C API (LLVMCreateDisasmCPUFeatures() in particular). Furthermore, we would need to make similar changes to the public C++ API to make MCTargetOptions available to MipsMCCodeEmitter, MipsMCAsmBackend, and the MIPS implementation of createMCSubtargetInfo() to be able to fix IAS support for the N32 ABI. This then leads to tools like llvm-objdump needing to pass an ABI name into the create*() functions or knowing when the backend will ignore the values given. In my opinion, the plumbing needed for this approach is difficult and produces a poor outcome.

Beyond the API changes, there are some odd inconsistencies that look like they'll cause further problems in the future. For example, IRObjectFile not specifying the ABI in its CollectAsmUndefinedRefs function can cause the occasional unexpected undefined references for some inline assembly. Another example is that that IRLinker won't consider O32/N32/N64 modules to be link-incompatible with each other because it only compares the triples stored in the modules. It therefore won't realize that the O32 LLVM-IR has lowered the calling convention differently to the N64 LLVM-IR and link them anyway to produce a bad output. Making IRLinker aware of the ABI would require the ABI to be serialized in the LLVM-IR.

[sdardis]

This looks ok to me as a starting point to begin rely only on the triple for n32/n64. @echristo ?

include/llvm/ADT/Triple.h

201–207

I think for the moment, AndroidABI32, ABI*, and GNUABI32 are superfluous. We can infer enough and/or rely on clang to disambiguate the precise target.

[atanasyan]

• Rebase the patch
• Reduce diff with trunk

[atanasyan]

This patch was published four months ago. Any comments?

[atanasyan]

And one more ping. Does the silence mean implicit approval?

[KoviRobi]

Hello,

I'd be interested to see this merged as well, but when I run the tests after applying the patch (onto 0d7672e plus my patch on https://reviews.llvm.org/D21465) I find that the following tests fail:

• test/MC/Mips/macro-li.d.s
• test/MC/Mips/macro-li.s.s

I think it is to do with lib/Target/Mips/MCTargetDesc/MipsMCAsmInfo.cpp lines 29-36

// FIXME: This condition isn't quite right but it's the best we can do until
//        this object can identify the ABI. It will misbehave when using O32
//        on a mips64*-* triple.
if ((TheTriple.getArch() == Triple::mipsel) ||
    (TheTriple.getArch() == Triple::mips)) {
  PrivateGlobalPrefix = "$";
  PrivateLabelPrefix = "$";
}

where we now should be able to access the ABI. But that file was not changed, the tests were broken by lib/Support/Triple.cpp at the end of getABIVariant:

// We have to keep the Arch and Environment in sync at the moment
// due to a false correlation between mips/mipsel and O32
// and mips64/mips64el and N64 that is required by the MIPS backend.
if (ABI == "o32")
  T = T.get32BitArchVariant();
else if (ABI == "n32" || ABI == "n64")
  T = T.get64BitArchVariant();

as the failing tests, for n32 and n64, specify the mips architecture (though with -mcpu=mips64 which seems to get ignored) with n32 and n64 ABI. But the above change forces mips64, thus the labels change from "$tmp" to ".Ltmp". However, I am not sure which behaviour we want: use dollar prefix for O32 ABIs only, in which case we need to change the test and MipsMCAsmInfo.cpp, or use dollar prefix for mips (not mips64) targets?

[KoviRobi]

So some simple testing using gcc -S and

int main(void) {
  x: goto x;
}

as the simplest test-case with labels I could think of, seem to suggest that we should use $label for o32, and .Llabel for n32/n64, which is the current behaviour, but in that case perhaps the test cases should be changed so they align? I have included the way I would change those files, note that it also clarifies the difference between using two adjacent 32-bit floating-point registers, versus using one 64-bit floating-point register that the mips32r2 and newer support.

macro-li-labels.patch15 KBDownload

[atanasyan]

The N32 ABI support will be implemented as another series of patches/changes. Like rL313160, rL313231, rL313873 ...

include/llvm/ADT/Triple.h

enum EnvironmentType {
     MuslEABIHF,
 
     MSVC,
     Itanium,
     Cygnus,
     AMDOpenCL,
     CoreCLR,
     OpenCL,
-    LastEnvironmentType = OpenCL
+    AndroidABI32,
+    AndroidABI64,
+    ABI32,
+    ABIN32,
+    ABI64,
+    GNUABI32,
+    GNUABIN32,
+    LastEnvironmentType = GNUABIN32
   };
   enum ObjectFormatType {
     UnknownObjectFormat,
 
     COFF,
     ELF,
     MachO,
   };
public:
   }
 
   bool isOSIAMCU() const {
     return getOS() == Triple::ELFIAMCU;
   }
 
   bool isGNUEnvironment() const {
     EnvironmentType Env = getEnvironment();
-    return Env == Triple::GNU || Env == Triple::GNUABI64 ||
+    return Env == Triple::GNU || Env == Triple::GNUABI32 ||
+           Env == Triple::GNUABIN32 || Env == Triple::GNUABI64 ||
            Env == Triple::GNUEABI || Env == Triple::GNUEABIHF ||
            Env == Triple::GNUX32;
   }
 
   bool isOSContiki() const {
     return getOS() == Triple::Contiki;
   }
 
public:
 
   /// Tests whether the target is the PS4 platform
   bool isPS4() const {
     return getVendor() == Triple::SCEI &&
            getOS() == Triple::PS4;
   }
 
   /// Tests whether the target is Android
-  bool isAndroid() const { return getEnvironment() == Triple::Android; }
+  bool isAndroid() const {
+    EnvironmentType Env = getEnvironment();
+    return Env == Triple::Android || Env == Triple::AndroidABI32 ||
+           Env == Triple::AndroidABI64;
+  }
 
   /// Tests whether the environment is musl-libc
   bool isMusl() const {
     return getEnvironment() == Triple::Musl ||
            getEnvironment() == Triple::MuslEABI ||
            getEnvironment() == Triple::MuslEABIHF;
   }
 
public:
   /// Form a triple with a little endian variant of the current architecture.
   ///
   /// This can be used to move across "families" of architectures where useful.
   ///
   /// \returns A new triple with a little endian architecture or an unknown
   ///          architecture if no such variant can be found.
   llvm::Triple getLittleEndianArchVariant() const;
 
+  /// Form a triple with variant of the current architecture and the specified
+  /// ABI.
+  ///
+  /// Generally speaking the target specifies the ABI in the triple if the ABI
+  /// has a large effect on the output (e.g. ELFCLASS32/ELFCLASS64, REL/RELA,
+  /// different sets of relocs) and/or is not link-compatible with other ABI's.
+  /// If the ABI is fairly small in effect (e.g. calling convention) then and/or
+  /// is link-compatible with other ABI's then MCTargetOptions is preferable.
+  ///
+  /// \param ABI The ABI name to use. If it is an empty string then the triple's
+  /// default is used.
+  /// \returns A new triple with the requested ABI or an unknown architecture
+  ///          if no such variant can be found. Also, an ABI name that is
+  ///          consistent with the triple.
+  std::pair<llvm::Triple, StringRef> getABIVariant(StringRef ABI) const;
+
   /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
   ///
   /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty
   /// string then the triple's arch name is used.
   StringRef getARMCPUForArch(StringRef Arch = StringRef()) const;
 
   /// Tests whether the target triple is little endian.
   ///

lib/Support/Triple.cpp

StringRef Triple::getOSTypeName(OSType Kind) {
   }
 
   llvm_unreachable("Invalid OSType");
 }
 
 StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   switch (Kind) {
   case UnknownEnvironment: return "unknown";
+  case ABI32: return "abi32";
+  case ABIN32: return "abin32";
+  case ABI64: return "abi64";
   case GNU: return "gnu";
+  case GNUABI32: return "gnuabi32";
+  case GNUABIN32: return "gnuabin32";
   case GNUABI64: return "gnuabi64";
   case GNUEABIHF: return "gnueabihf";
   case GNUEABI: return "gnueabi";
   case GNUX32: return "gnux32";
   case CODE16: return "code16";
   case EABI: return "eabi";
   case EABIHF: return "eabihf";
   case Android: return "android";
+  case AndroidABI32: return "androidabi32";
+  case AndroidABI64: return "androidabi64";
   case Musl: return "musl";
   case MuslEABI: return "musleabi";
   case MuslEABIHF: return "musleabihf";
   case MSVC: return "msvc";
   case Itanium: return "itanium";
   case Cygnus: return "cygnus";
   case AMDOpenCL: return "amdopencl";
   case CoreCLR: return "coreclr";
return StringSwitch<Triple::OSType>(OSName)
     .StartsWith("watchos", Triple::WatchOS)
     .StartsWith("mesa3d", Triple::Mesa3D)
     .StartsWith("contiki", Triple::Contiki)
     .Default(Triple::UnknownOS);
 }
 
 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
   return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
+    .StartsWith("abi32", Triple::ABI32)
+    .StartsWith("abin32", Triple::ABIN32)
+    .StartsWith("abi64", Triple::ABI64)
     .StartsWith("eabihf", Triple::EABIHF)
     .StartsWith("eabi", Triple::EABI)
+    .StartsWith("gnuabi32", Triple::GNUABI32)
+    .StartsWith("gnuabin32", Triple::GNUABIN32)
     .StartsWith("gnuabi64", Triple::GNUABI64)
     .StartsWith("gnueabihf", Triple::GNUEABIHF)
     .StartsWith("gnueabi", Triple::GNUEABI)
     .StartsWith("gnux32", Triple::GNUX32)
     .StartsWith("code16", Triple::CODE16)
     .StartsWith("gnu", Triple::GNU)
+    .StartsWith("androidabi32", Triple::AndroidABI32)
+    .StartsWith("androidabi64", Triple::AndroidABI64)
     .StartsWith("android", Triple::Android)
     .StartsWith("musleabihf", Triple::MuslEABIHF)
     .StartsWith("musleabi", Triple::MuslEABI)
     .StartsWith("musl", Triple::Musl)
     .StartsWith("msvc", Triple::MSVC)
     .StartsWith("itanium", Triple::Itanium)
     .StartsWith("cygnus", Triple::Cygnus)
     .StartsWith("amdopencl", Triple::AMDOpenCL)
bool Triple::isLittleEndian() const {
   case Triple::renderscript32:
   case Triple::renderscript64:
     return true;
   default:
     return false;
   }
 }
 
+std::pair<llvm::Triple, StringRef> Triple::getABIVariant(StringRef ABI) const {
+  Triple T(*this);
+  switch (getArch()) {
+  default:
+    if (ABI.empty())
+      return std::make_pair(T, ABI);
+    T.setArch(Triple::UnknownArch);
+    return std::make_pair(T, ABI);
+
+  case Triple::arm:
+  case Triple::armeb:
+  case Triple::aarch64:
+  case Triple::aarch64_be:
+  case Triple::thumb:
+  case Triple::thumbeb:
+    if (ABI.empty() || ABI == "aapcs16" || ABI == "darwinpcs" ||
+        ABI == "ilp32" || ABI.startswith("apcs") || ABI.startswith("aapcs"))
+      return std::make_pair(T, ABI);
+    T.setArch(Triple::UnknownArch);
+    return std::make_pair(T, ABI);
+
+  case Triple::ppc64:
+  case Triple::ppc64le:
+    if (ABI.empty() || ABI.startswith("elfv1") || ABI.startswith("elfv2"))
+      return std::make_pair(T, ABI);
+    T.setArch(Triple::UnknownArch);
+    return std::make_pair(T, ABI);
+
+  case Triple::mips:
+  case Triple::mipsel:
+  case Triple::mips64:
+  case Triple::mips64el: {
+    if (ABI.empty()) {
+      if (getArch() == Triple::mips || getArch() == Triple::mipsel)
+        ABI = "o32";
+      else
+        ABI = "n64";
+    }
+
+    // For MIPS the ABI name provided by a separate option supersedes
+    // the environment specified in a triple. Let's adjust the triple
+    // accordingly.
+    switch (T.getEnvironment()) {
+    default:
+      T.setEnvironment(Triple::UnknownEnvironment);
+      break;
+    case Triple::Android:
+    case Triple::AndroidABI64:
+      T.setEnvironment(StringSwitch<EnvironmentType>(ABI)
+                           .Case("o32", Triple::AndroidABI32)
+                           .Case("n64", Triple::AndroidABI64)
+                           .Default(Triple::UnknownEnvironment));
+      break;
+    case Triple::UnknownEnvironment:
+    case Triple::ABI32:
+    case Triple::ABIN32:
+    case Triple::ABI64:
+      T.setEnvironment(StringSwitch<EnvironmentType>(ABI)
+                           .Case("o32", Triple::ABI32)
+                           .Case("n32", Triple::ABIN32)
+                           .Case("n64", Triple::ABI64)
+                           .Default(Triple::UnknownEnvironment));
+      break;
+    case Triple::GNU:
+    case Triple::GNUABI32:
+    case Triple::GNUABIN32:
+    case Triple::GNUABI64:
+      T.setEnvironment(StringSwitch<EnvironmentType>(ABI)
+                           .Case("o32", Triple::GNUABI32)
+                           .Case("n32", Triple::GNUABIN32)
+                           .Case("n64", Triple::GNUABI64)
+                           .Default(Triple::UnknownEnvironment));
+      break;
+    }
+
+    if (T.getEnvironment() == Triple::UnknownEnvironment) {
+      T.setArch(Triple::UnknownArch);
+      return std::make_pair(T, ABI);
+    }
+
+    // We have to keep the Arch and Environment in sync at the moment
+    // due to a false correlation between mips/mipsel and O32
+    // and mips64/mips64el and N64 that is required by the MIPS backend.
+    if (ABI == "o32")
+      T = T.get32BitArchVariant();
+    else if (ABI == "n32" || ABI == "n64")
+      T = T.get64BitArchVariant();
+
+    return std::make_pair(T, ABI);
+  }
+  }
+}
+
 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:

lib/Target/Mips/MCTargetDesc/MipsABIInfo.cpp

 MipsABIInfo MipsABIInfo::computeTargetABI(const Triple &TT, StringRef CPU,
                                           const MCTargetOptions &Options) {
   if (Options.getABIName().startswith("o32"))
     return MipsABIInfo::O32();
   if (Options.getABIName().startswith("n32"))
     return MipsABIInfo::N32();
   if (Options.getABIName().startswith("n64"))
     return MipsABIInfo::N64();
+
   assert(Options.getABIName().empty() && "Unknown ABI option for MIPS");
+  if (TT.getEnvironment() == Triple::ABI32 ||
+      TT.getEnvironment() == Triple::AndroidABI32 ||
+      TT.getEnvironment() == Triple::GNUABI32)
+    return MipsABIInfo::O32();
+  if (TT.getEnvironment() == Triple::ABIN32 ||
+      TT.getEnvironment() == Triple::GNUABIN32)
+    return MipsABIInfo::N32();
+  if (TT.getEnvironment() == Triple::ABI64 ||
+      TT.getEnvironment() == Triple::AndroidABI64 ||
+      TT.getEnvironment() == Triple::GNUABI64)
+    return MipsABIInfo::N64();
 
   if (TT.getArch() == Triple::mips64 || TT.getArch() == Triple::mips64el)
     return MipsABIInfo::N64();
   return MipsABIInfo::O32();
 }
 
 unsigned MipsABIInfo::GetStackPtr() const {
   return ArePtrs64bit() ? Mips::SP_64 : Mips::SP;

test/CodeGen/Mips/compactbranches/no-beqzc-bnezc.ll

if.then:
     ret i64 1
 
   if.end:
     ret i64 0
 }
 
 define i32 @f6(i32 %a) {
 ; CHECK-LABEL: f6:
-; CHECK: beqzc ${{[0-9]+}}, $BB
+; CHECK: beqzc ${{[0-9]+}},
 
   %cmp = icmp eq i32 %a, 0
   br i1 %cmp, label %if.then, label %if.end
 
   if.then:
     ret i32 1
 
   if.end:
     ret i32 0
 }
 
 define i32 @f7(i32 %a) {
 ; CHECK-LABEL: f7:
-; CHECK: bnezc ${{[0-9]+}}, $BB
+; CHECK: bnezc ${{[0-9]+}},
 
   %cmp = icmp eq i32 0, %a
   br i1 %cmp, label %if.then, label %if.end
 
   if.then:
     ret i32 1
 
   if.end:
     ret i32 0
 }

test/MC/Mips/elf_reginfo.s

 # These *MUST* match the output of gas compiled with the same triple and
-# corresponding options (-mabi=64 -> -mattr=+n64 for example).
+# corresponding options.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64el-linux -target-abi n64 %s -o - \
 # RUN: | llvm-readobj -s | FileCheck --check-prefix=CHECK_64 %s
 # RUN: llvm-mc -filetype=obj -triple=mipsel %s -target-abi n32 -o - \
 # RUN: | llvm-readobj -s | FileCheck --check-prefix=CHECK_32 %s
 
 # Check for register information sections.
 #

test/MC/Mips/expansion-jal-sym-pic.s

 # O32: addiu  $25, $25, %lo($tmp0)    # encoding: [0x27,0x39,A,A]
 # O32:                                #   fixup A - offset: 0, value: %lo($tmp0), kind:   fixup_Mips_LO16
 
 # ELF-O32:      8f 99 00 00 lw $25, 0($gp)
 # ELF-O32-NEXT:                 R_MIPS_GOT16 .text
 # ELF-O32-NEXT: 27 39 00 54 addiu $25, $25, 84
 # ELF-O32-NEXT:                 R_MIPS_LO16 .text
 
-# N32: lw  $25, %got_disp($tmp0)($gp) # encoding: [0x8f,0x99,A,A]
-# N32:                                #   fixup A - offset: 0, value: %got_disp($tmp0), kind:   fixup_Mips_GOT_DISP
+# N32: lw  $25, %got_disp(.Ltmp0)($gp) # encoding: [0x8f,0x99,A,A]
+# N32:                                 #   fixup A - offset: 0, value: %got_disp(.Ltmp0), kind:   fixup_Mips_GOT_DISP
 
 # ELF-N32:      8f 99 00 00 lw $25, 0($gp)
 # ELF-N32-NEXT:                 R_MIPS_GOT_DISP/R_MIPS_NONE/R_MIPS_NONE .Ltmp0
 
 # N64: ld  $25, %got_disp(.Ltmp0)($gp) # encoding: [0xdf,0x99,A,A]
 # N64:                                 #   fixup A - offset: 0, value: %got_disp(.Ltmp0), kind:   fixup_Mips_GOT_DISP
 
 # ELF-N64:      df 99 00 00 ld $25, 0($gp)

tools/llc/llc.cpp

static int compileModule(char **argv, LLVMContext &Context) {
 
   TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
   Options.DisableIntegratedAS = NoIntegratedAssembler;
   Options.MCOptions.ShowMCEncoding = ShowMCEncoding;
   Options.MCOptions.MCUseDwarfDirectory = EnableDwarfDirectory;
   Options.MCOptions.AsmVerbose = AsmVerbose;
   Options.MCOptions.PreserveAsmComments = PreserveComments;
 
+  // Adjust and make consistent the triple and ABIName if we can.
+  std::tie(TheTriple, Options.MCOptions.ABIName) =
+      TheTriple.getABIVariant(Options.MCOptions.ABIName);
+  if (TheTriple.getArch() == Triple::UnknownArch) {
+    errs() << argv[0]
+           << ": error: invalid ABI name: " << Options.MCOptions.ABIName
+           << "\n";
+    return 1;
+  }
+
   std::unique_ptr<TargetMachine> Target(
       TheTarget->createTargetMachine(TheTriple.getTriple(), CPUStr, FeaturesStr,
                                      Options, getRelocModel(), CMModel, OLvl));
 
   assert(Target && "Could not allocate target machine!");
 
   // If we don't have a module then just exit now. We do this down
   // here since the CPU/Feature help is underneath the target machine

tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
   const char *ProgName = argv[0];
   const Target *TheTarget = GetTarget(ProgName);
   if (!TheTarget)
     return 1;
   // Now that GetTarget() has (potentially) replaced TripleName, it's safe to
   // construct the Triple object.
   Triple TheTriple(TripleName);
 
+  // Adjust and make consistent the triple and ABIName if we can.
+  std::tie(TheTriple, MCOptions.ABIName) =
+      TheTriple.getABIVariant(MCOptions.ABIName);
+  if (TheTriple.getArch() == Triple::UnknownArch) {
+    errs() << ProgName << ": error: invalid ABI name: " << MCOptions.ABIName
+           << "\n";
+    return 1;
+  }
+  TripleName = TheTriple.str();
+
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(InputFilename);
   if (std::error_code EC = BufferPtr.getError()) {
     errs() << InputFilename << ": " << EC.message() << '\n';
     return 1;
   }
   MemoryBuffer *Buffer = BufferPtr->get();
 

unittests/ADT/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
   T = Triple("riscv64-unknown-freebsd");
   EXPECT_EQ(Triple::riscv64, T.getArch());
   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
   EXPECT_EQ(Triple::FreeBSD, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
+  T = Triple("mips-mti-linux-gnu");
+  EXPECT_EQ(Triple::mips, T.getArch());
+  EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNU, T.getEnvironment());
+
+  T = Triple("mipsel-img-linux-gnu");
+  EXPECT_EQ(Triple::mipsel, T.getArch());
+  EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNU, T.getEnvironment());
+
+  T = Triple("mips64-mti-linux-gnu");
+  EXPECT_EQ(Triple::mips64, T.getArch());
+  EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNU, T.getEnvironment());
+
+  T = Triple("mips64el-img-linux-gnu");
+  EXPECT_EQ(Triple::mips64el, T.getArch());
+  EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNU, T.getEnvironment());
+
+  T = Triple("mips64el-img-linux-gnuabin32");
+  EXPECT_EQ(Triple::mips64el, T.getArch());
+  EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
+
+  T = Triple("mips64el-unknown-linux-gnuabi64");
+  EXPECT_EQ(Triple::mips64el, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
+
   T = Triple("huh");
   EXPECT_EQ(Triple::UnknownArch, T.getArch());
 }
 
 static std::string Join(StringRef A, StringRef B, StringRef C) {
   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
   return Str;
 }
TEST(TripleTest, EndianArchVariants) {
   EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch());
   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 
   T.setArch(Triple::lanai);
   EXPECT_EQ(Triple::lanai, T.getBigEndianArchVariant().getArch());
   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 }
 
+TEST(TripleTest, ABIVariants) {
+  Triple T, MutatedT;
+  StringRef MutatedABI;
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("").first.getArch());
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("32").first.getArch());
+
+  T.setArch(Triple::UnknownArch);
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("").first.getArch());
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("32").first.getArch());
+
+  // Try a triple that doesn't mutate the triple in getABIVariant().
+  // This should leave the triple and abi unchanged.
+  T = Triple("x86_64-pc-linux-gnu");
+  std::tie(MutatedT, MutatedABI) = T.getABIVariant("");
+  EXPECT_EQ(T, MutatedT);
+  EXPECT_EQ("", MutatedABI);
+
+  // Try an unsupported ABI name. This should change the arch component of the
+  // triple to UnknownArch. Other parts of the result are undefined.
+  std::tie(MutatedT, MutatedABI) = T.getABIVariant("32");
+  EXPECT_EQ(Triple::UnknownArch, MutatedT.getArch());
+
+  for (const auto &TripleStr :
+       {"mips-linux-gnu", "mipsel-linux-gnu", "mips-mti-linux-gnu",
+        "mipsel-img-linux-gnu", "mips64-linux-gnu", "mips64el-linux-gnu",
+        "mips64-mti-linux-gnu", "mips64el-img-linux-gnu"}) {
+    T = Triple(Triple::normalize(TripleStr));
+    std::pair<Triple, StringRef> Default = T.getABIVariant("");
+    std::pair<Triple, StringRef> O32 = T.getABIVariant("o32");
+    std::pair<Triple, StringRef> N32 = T.getABIVariant("n32");
+    std::pair<Triple, StringRef> N64 = T.getABIVariant("n64");
+
+    EXPECT_EQ(T.getArch(), Default.first.getArch());
+    EXPECT_EQ(T.get32BitArchVariant().getArch(), O32.first.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N32.first.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N64.first.getArch());
+
+    EXPECT_EQ(T.getVendor(), Default.first.getVendor());
+    EXPECT_EQ(T.getVendor(), O32.first.getVendor());
+    EXPECT_EQ(T.getVendor(), N32.first.getVendor());
+    EXPECT_EQ(T.getVendor(), N64.first.getVendor());
+
+    EXPECT_EQ(T.getOS(), Default.first.getOS());
+    EXPECT_EQ(T.getOS(), O32.first.getOS());
+    EXPECT_EQ(T.getOS(), N32.first.getOS());
+    EXPECT_EQ(T.getOS(), N64.first.getOS());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? Triple::GNUABI64
+                  : Triple::GNUABI32,
+              Default.first.getEnvironment());
+    EXPECT_EQ(Triple::GNUABI32, O32.first.getEnvironment());
+    EXPECT_EQ(Triple::GNUABIN32, N32.first.getEnvironment());
+    EXPECT_EQ(Triple::GNUABI64, N64.first.getEnvironment());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? "n64"
+                  : "o32",
+              Default.second);
+    EXPECT_EQ("o32", O32.second);
+    EXPECT_EQ("n32", N32.second);
+    EXPECT_EQ("n64", N64.second);
+
+    // Try an unsupported ABI name. This should change the arch component of the
+    // triple to UnknownArch. Other values are undefined.
+    std::pair<Triple, StringRef> Foo = T.getABIVariant("foo");
+    EXPECT_EQ(Triple::UnknownArch, Foo.first.getArch());
+  }
+
+  for (const auto &TripleStr :
+       {"mipsel-linux-android", "mips64el-linux-android"}) {
+    T = Triple(Triple::normalize(TripleStr));
+    std::pair<Triple, StringRef> Default = T.getABIVariant("");
+    std::pair<Triple, StringRef> O32 = T.getABIVariant("o32");
+    std::pair<Triple, StringRef> N32 = T.getABIVariant("n32");
+    std::pair<Triple, StringRef> N64 = T.getABIVariant("n64");
+
+    EXPECT_EQ(T.getArch(), Default.first.getArch());
+    EXPECT_EQ(T.get32BitArchVariant().getArch(), O32.first.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N64.first.getArch());
+
+    EXPECT_EQ(T.getVendor(), Default.first.getVendor());
+    EXPECT_EQ(T.getVendor(), O32.first.getVendor());
+    EXPECT_EQ(T.getVendor(), N64.first.getVendor());
+
+    EXPECT_EQ(T.getOS(), Default.first.getOS());
+    EXPECT_EQ(T.getOS(), O32.first.getOS());
+    EXPECT_EQ(T.getOS(), N64.first.getOS());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? Triple::AndroidABI64
+                  : Triple::AndroidABI32,
+              Default.first.getEnvironment());
+    EXPECT_EQ(Triple::AndroidABI32, O32.first.getEnvironment());
+    EXPECT_EQ(Triple::AndroidABI64, N64.first.getEnvironment());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? "n64"
+                  : "o32",
+              Default.second);
+    EXPECT_EQ("o32", O32.second);
+    EXPECT_EQ("n64", N64.second);
+
+    // Try an unsupported ABI name. This should change the arch component of the
+    // triple to UnknownArch. Other values are undefined.
+    std::pair<Triple, StringRef> Foo = T.getABIVariant("foo");
+    EXPECT_EQ(Triple::UnknownArch, Foo.first.getArch());
+
+    // N32 is known to LLVM but unsupported for Android.
+    EXPECT_EQ(Triple::UnknownArch, N32.first.getArch());
+  }
+
+  for (const auto &TripleStr :
+       {"mips-linux", "mipsel-linux", "mips-mti-linux", "mipsel-img-linux",
+        "mips-unknown-freebsd", "mips64-linux", "mips64el-linux",
+        "mips64-mti-linux", "mips64el-img-linux", "mips64-unknown-freebsd"}) {
+    T = Triple(Triple::normalize(TripleStr));
+    std::pair<Triple, StringRef> Default = T.getABIVariant("");
+    std::pair<Triple, StringRef> O32 = T.getABIVariant("o32");
+    std::pair<Triple, StringRef> N32 = T.getABIVariant("n32");
+    std::pair<Triple, StringRef> N64 = T.getABIVariant("n64");
+    std::pair<Triple, StringRef> Foo = T.getABIVariant("foo");
+
+    EXPECT_EQ(T.getArch(), Default.first.getArch());
+    EXPECT_EQ(T.get32BitArchVariant().getArch(), O32.first.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N32.first.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N64.first.getArch());
+    EXPECT_EQ(Triple::UnknownArch, Foo.first.getArch());
+
+    EXPECT_EQ(T.getVendor(), Default.first.getVendor());
+    EXPECT_EQ(T.getVendor(), O32.first.getVendor());
+    EXPECT_EQ(T.getVendor(), N32.first.getVendor());
+    EXPECT_EQ(T.getVendor(), N64.first.getVendor());
+
+    EXPECT_EQ(T.getOS(), Default.first.getOS());
+    EXPECT_EQ(T.getOS(), O32.first.getOS());
+    EXPECT_EQ(T.getOS(), N32.first.getOS());
+    EXPECT_EQ(T.getOS(), N64.first.getOS());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? Triple::ABI64
+                  : Triple::ABI32,
+              Default.first.getEnvironment());
+    EXPECT_EQ(Triple::ABI32, O32.first.getEnvironment());
+    EXPECT_EQ(Triple::ABIN32, N32.first.getEnvironment());
+    EXPECT_EQ(Triple::ABI64, N64.first.getEnvironment());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? "n64"
+                  : "o32",
+              Default.second);
+    EXPECT_EQ("o32", O32.second);
+    EXPECT_EQ("n32", N32.second);
+    EXPECT_EQ("n64", N64.second);
+    EXPECT_EQ("foo", Foo.second);
+  }
+}
+
 TEST(TripleTest, getOSVersion) {
   Triple T;
   unsigned Major, Minor, Micro;
 
   T = Triple("i386-apple-darwin9");
   EXPECT_TRUE(T.isMacOSX());
   EXPECT_FALSE(T.isiOS());
   EXPECT_FALSE(T.isArch16Bit());