[llc+llvm-mc] Prefer applying -mabi to the triple where possible and allow Mips to take ABI information in the triple.

[sdardis]

Summary

The primary aim of this patch (and the clang counterpart) is to make it possible
to enable IAS by default for the N64 ABI (which is almost ready for it) without
also enabling it for the N32 ABI (which is definitely not ready). The same
change also lays the necessary ground work for fixing the N32 support such as
picking the right ELFCLASS and relocation encoding (N32 doesn't support the
3-relocs-in-1 encoding that N64 has).

The overall approach is to move away from the MCTargetOptions::ABIName way of
specifying the ABI (which until fairly recently was only in use by MIPS) and
move to specifying the ABI in the triple like other targets. Clang and API
users will then be required to specify the correct triple for the ABI they wish
to target.

In more detail:
Added the following environment values to llvm::Triple to explicitly
specify the ABI as part of the environment component of the triple:

• ABI32, ABIN32, ABI64
• AndroidABI32, AndroidABI64
• GNUABI32, GNUABIN32, GNUABI64

ABI32/AndroidABI32/GNUABI32 are used internally to distinguish between the case
where O32 has been specified, and the case where the default ABI is implied.
This matters for triples such as mips64-linux-gnu where the default ABI is
context sensitive and could be any of the three main ABI's depending on
the environment. It is unlikely that these 'ABI32' suffixes will be seen in
GNU Triples.

In this patch, the MIPS backend will accept ABI's through either
MCTargetOptions::ABIName or the triple. A subsequent patch will restrict
this so that the MIPS backend only accepts ABI information from the triple
to avoid the potential for confusion caused by mismatches between the
triple and MCTargetOptions. At that point a corresponding clang patch will
be required to ensure proper usage and C++ API users who pass non-empty ABI
names will need to add something like:

Triple ABITriple = TT.getABIVariant(ABIName)
if (ABITriple.getArch() != Triple::UnknownArch) {
  TT = ABITriple;
  ABIName = ""
}

to their code. C-API users will be unaffected by this requirement since they
are currently unable to specify the ABI.

The test changes are as follows:
test/CodeGen/Mips/fp16-promote.ll

Changed gnueabi to gnu in the triple. EABI has been removed recently
because it was untested and had bitrotted.

test/MC/Mips/cpsetup.s

Made the OS component of the triple known since getABIVariant() needs to
know the OS to apply the ABI information to the triple.

test/MC/Mips/mips64-register-names-o32.s:

Switched daddiu's for addiu's since O32 prohibits the use of 64-bit GPRs.

See http://reviews.llvm.org/D20916 for an explanation as to why
MCTargetOptions::ABIName doesn't work for Mips.

Depends on D21466 and D21465

Patch By: Daniel Sanders

[dsanders]

Fixed a small rebase mistake that only became clear when a follow-up patch was applied

[• rafael]

Are the new triples something we are inventing or are they supported
already by some tool. For example, can binutils be configured to
target mips64-linuxgnuabi64?

Cheers,
Rafael

[dsanders]

Are the new triples something we are inventing or are they supported already by some tool.

A bit of both. Most of them are inventions for the LLVM internals. However, 'gnuabin32' and 'gnuabi64' are chosen to coincide with Debian's multiarch tuples (https://wiki.debian.org/Multiarch/Tuples, search for 'mips-linux-gnu' to find the mips examples) and will be used by the N32 port of Debian (if/when we do it) and is used by the new N64 port of Debian.

These triples are internal to LLVM and I'm expecting them to be (almost) invisible to the end user. Clang users will still use whatever triple and options they use today. Existing API users, existing LLVM-IR, lldb, llc, llvm-mc, etc. can also stick to their current triples if they wish but they won't be able to target N32 (which is the same position they're in at the moment). The reason I say 'almost' invisible is because the triples will show up in the 'target triple' statement of newly generated LLVM-IR. I also plan to have them appear in the output of 'clang --version' so that we can easily find out what the target for a given set of options is.

For example, can binutils be configured to target mips64-linux-gnuabi64?

On Debian, yes and it selects the appropriate behaviour to target the N64 port of Debian. Elsewhere, yes (because of a wildcard match 'linux-gnu*') and anything special about it compared to mips64-linux-gnu is specified in options to ./configure.

[dsanders]

Refresh patch following the commit of r273557

[dsanders]

Refreshed patch. This one is affected by the part of the llvm-dev thread about making targets consistent.
This patch only moves the Mips target to this mechanism at the moment. I'll develop the ARM/X86/other
patches separately and we can either commit them in sequence or fold them all into a single patch.

[dsanders]

This patch only moves the Mips target to this mechanism at the moment. I'll develop the ARM/X86/other
patches separately and we can either commit them in sequence or fold them all into a single patch.

X86 doesn't need any changes because it doesn't support -target-abi (or -mabi in clang) at all.

PowerPC doesn't need any changes because the ABI only affects codegen.

That just leaves ARM since no other target is using -target-abi. I'm still confirming whether we need any changes to account for ARM.

[echristo]

So now you have a situation where there are two methods, that are both
happening at the same time, of passing the ABI to the backend. There needs
to be one.

[dsanders]

So now you have a situation where there are two methods, that are both happening at the same time, of passing the ABI to the backend. There needs to be one.

That's not caused by this patch (or series), it's been the case since r224492. This patch just makes it obvious because a command line option is doing the substitution instead of the human writing the tests.

There are three camps today:

• ARM/PowerPC pass the ABI in _both_ the triple and MCTargetOptions
• Mips passes the ABI in the triple in some cases (O32, N64) and MCTargetOptions in other cases (N32).
• X86/everyone-else pass the ABI in the triple only

My patch series started out trying to reduce this to:

• ARM/PowerPC pass the ABI in _both_ the triple and MCTargetOptions
• Mips/X86/everyone-else pass the ABI in the triple only

I'm currently trying to re-work the plan to reduce this further one of these three options:

• ARM/PowerPC/Mips/X86/everyone-else pass the ABI in _both_ the triple and MCTargetOptions
• ARM/PowerPC/Mips/X86/everyone-else pass the ABI in MCTargetOptions only (already ruled out because MCTargetOptions is not sufficient for ARM/X86/Mips)
• ARM/PowerPC/Mips/X86/everyone-else pass the ABI in the triple only. (not ruled out yet but is significantly trickier than the first option)

The comments you're replying to are in line with aiming for the first of these three options.

I can't reach the end point in a single leap without breaking things or ending up with a truly massive patch. I need you to let me incrementally move towards it so that the trunk always works.

---

From: Eric Christopher [[e-mail]]
Sent: 11 July 2016 18:18
To: [e-mail]; Daniel Sanders
Cc: [e-mail]
Subject: Re: [PATCH] D21467: [llc+llvm-mc] Prefer applying -mabi to the triple where possible and allow Mips to take ABI information in the triple.

So now you have a situation where there are two methods, that are both happening at the same time, of passing the ABI to the backend. There needs to be one.

[dsanders]

Changed Triple::getABIVariant() such that it returns a (possibly modified)
triple as well as a (possibly modified) ABI name. This allows it to handle
all three groups of target:

• Those that pass ABI information in both the triple and MCTargetOptions (ARM/PowerPC).
• Mips which passes the ABI in the triple in some respects (mips/mipsel => O32, mips64/mips64el => N32/N64) and in MCTargetOptions only in others (N32 vs N64).**
• Those that that pass ABI information in the triple only (X86/everyone-else)

• This is slightly different to the description I gave last night. Both are accurate but this one is more complete. The main point is that Mips is inconsistent.

At this point Mips is edging into the X86/everyone-else camp. A clang
patch (D21070) and another llvm patch (D21069) are needed to complete that
transition. This will leave us with two groups of targets (ARM/PowerPC, and
Mips/X86/everyone-else) at which point we can start reducing it down to a
single group.

Removed an N32 Android test from test/CodeGen/Mips/ehframe-indirect.ll since N32 isn't supported on Android.

[dsanders]

@echristo: Does the latest version help resolve your concerns?

[dsanders]

clang uses 'darwinpcs' which isn't mentioned in the backend. Added it to the list of ABI names.

[dsanders]

Refresh and ping following upstream test updates and addition of Debian mips64el support.

[dsanders]

Triple::isAndroid() and MipsABIInfo::computeTargetABI() now account for the
AndroidABI32 and AndroidABI64 enums. This prevents some breakage I noticed
while trying to make the clang driver mutate the triple instead of cc1/cc1as.

[dsanders]

Refresh and ping

[dsanders]

One last ping since I need to either commit this series next week or hand over to a colleague to continue it.

[sdardis]

Taking over this patch series.

[sdardis]

Rebase + ping.

[sdardis]

Ping.

[sdardis]

Ping.

[sdardis]

Refresh and ping.

[sdardis]

Correct failing test in diff.

[sdardis]

Rebase and ping.

include/llvm/ADT/Triple.h

enum EnvironmentType {
     Android,
     Musl,
 
     MSVC,
     Itanium,
     Cygnus,
     AMDOpenCL,
     CoreCLR,
-    LastEnvironmentType = CoreCLR
+    AndroidABI32,
+    AndroidABI64,
+    ABI32,
+    ABIN32,
+    ABI64,
+    GNUABI32,
+    GNUABIN32,
+    GNUABI64,
+    LastEnvironmentType = GNUABI64
   };
   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::GNUEABI ||
-           Env == Triple::GNUEABIHF || Env == Triple::GNUX32;
+    return Env == Triple::GNU || Env == Triple::GNUABI32 ||
+           Env == Triple::GNUABIN32 || Env == Triple::GNUABI64 ||
+           Env == Triple::GNUEABI || Env == Triple::GNUEABIHF ||
+           Env == Triple::GNUX32;
   }
 
   /// Checks if the environment could be MSVC.
   bool isWindowsMSVCEnvironment() const {
     return getOS() == Triple::Win32 &&
            (getEnvironment() == Triple::UnknownEnvironment ||
             getEnvironment() == Triple::MSVC);
   }
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.
+  llvm::Triple 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;
 
   /// @}
   /// @name Static helpers for IDs.

lib/Support/Triple.cpp

const char *Triple::getOSTypeName(OSType Kind) {
   }
 
   llvm_unreachable("Invalid OSType");
 }
 
 const char *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 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("tvos", Triple::TvOS)
     .StartsWith("watchos", Triple::WatchOS)
     .StartsWith("mesa3d", Triple::Mesa3D)
     .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("musl", Triple::Musl)
     .StartsWith("msvc", Triple::MSVC)
     .StartsWith("itanium", Triple::Itanium)
     .StartsWith("cygnus", Triple::Cygnus)
     .StartsWith("amdopencl", Triple::AMDOpenCL)
     .StartsWith("coreclr", Triple::CoreCLR)
     .Default(Triple::UnknownEnvironment);
Triple Triple::getLittleEndianArchVariant() const {
   case Triple::mips64:     T.setArch(Triple::mips64el); break;
   case Triple::mips:       T.setArch(Triple::mipsel);   break;
   case Triple::ppc64:      T.setArch(Triple::ppc64le);  break;
   case Triple::sparc:      T.setArch(Triple::sparcel);  break;
   }
   return T;
 }
 
+llvm::Triple Triple::getABIVariant(StringRef ABI) const {
+  Triple T(*this);
+  switch (getArch()) {
+  default:
+    T.setArch(UnknownArch);
+    return T;
+
+  case Triple::mips:
+  case Triple::mipsel:
+  case Triple::mips64:
+  case Triple::mips64el: {
+    EnvironmentType NewEnv;
+
+    if (ABI == "")
+      ABI = (getArch() == Triple::mips || getArch() == Triple::mipsel) ? "o32" : "n64";
+
+    switch (T.getEnvironment()) {
+    default:
+      T.setArch(Triple::UnknownArch);
+      return T;
+
+    case Triple::Android:
+    case Triple::AndroidABI64:
+      NewEnv = 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:
+      NewEnv = 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:
+      NewEnv = StringSwitch<EnvironmentType>(ABI)
+                   .Case("o32", Triple::GNUABI32)
+                   .Case("n32", Triple::GNUABIN32)
+                   .Case("n64", Triple::GNUABI64)
+                   .Default(Triple::UnknownEnvironment);
+      break;
+    }
+
+    if (NewEnv == Triple::UnknownEnvironment) {
+      T.setArch(Triple::UnknownArch);
+      return T;
+    }
+
+    // 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();
+
+    if (NewEnv != T.getEnvironment())
+      T.setEnvironment(NewEnv);
+    return T;
+  }
+  }
+}
+
 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,
   if (Options.getABIName().startswith("o32"))
     return MipsABIInfo::O32();
   else if (Options.getABIName().startswith("n32"))
     return MipsABIInfo::N32();
   else if (Options.getABIName().startswith("n64"))
     return MipsABIInfo::N64();
   else if (!Options.getABIName().empty())
     llvm_unreachable("Unknown ABI option for MIPS");
+  else if (TT.getEnvironment() == Triple::ABI32 ||
+           TT.getEnvironment() == Triple::GNUABI32)
+    return MipsABIInfo::O32();
+  else if (TT.getEnvironment() == Triple::ABIN32 ||
+           TT.getEnvironment() == Triple::GNUABIN32)
+    return MipsABIInfo::N32();
+  else if (TT.getEnvironment() == Triple::ABI64 ||
+           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/fp16-promote.ll

-; RUN: llc -asm-verbose=false -mtriple=mipsel-linux-gnueabi -relocation-model=pic < %s | FileCheck %s -check-prefix=CHECK-LIBCALL
+; RUN: llc -asm-verbose=false -mtriple=mipsel-linux-gnu -relocation-model=pic < %s | FileCheck %s -check-prefix=CHECK-LIBCALL
 
 ; CHECK-LIBCALL-LABEL: test_fadd:
 ; CHECK-LIBCALL: %call16(__gnu_h2f_ieee)
 ; CHECK-LIBCALL: %call16(__gnu_h2f_ieee)
 ; CHECK-LIBCALL-DAG: add.s
 ; CHECK-LIBCALL-DAG: %call16(__gnu_f2h_ieee)
 define void @test_fadd(half* %p, half* %q) #0 {
   %a = load half, half* %p, align 2

test/MC/Mips/cpsetup.s

 # RUN: llvm-mc -triple mips64-unknown-linux -mabi=o32 -filetype=obj -o - %s | \
 # RUN:   llvm-objdump -d -r - | FileCheck -check-prefix=ALL -check-prefix=O32 %s
 
-# RUN: llvm-mc -triple mips64-unknown-unknown -mabi=o32 %s | \
+# RUN: llvm-mc -triple mips64-unknown-linux -mabi=o32 %s | \
 # RUN:   FileCheck -check-prefix=ALL -check-prefix=ASM %s
 
 # RUN: llvm-mc -triple mips64-unknown-linux -mabi=n32 -filetype=obj -o - %s | \
 # RUN:   llvm-objdump -d -r - | \
 # RUN:   FileCheck -check-prefix=ALL -check-prefix=NXX -check-prefix=N32 %s
 
-# RUN: llvm-mc -triple mips64-unknown-unknown -mabi=n32 %s | \
+# RUN: llvm-mc -triple mips64-unknown-linux -mabi=n32 %s | \
 # RUN:   FileCheck -check-prefix=ALL -check-prefix=ASM %s
 
 # RUN: llvm-mc -triple mips64-unknown-linux %s -filetype=obj -o - | \
 # RUN:   llvm-objdump -d -r - | \
 # RUN:   FileCheck -check-prefix=ALL -check-prefix=NXX -check-prefix=N64 %s
 
-# RUN: llvm-mc -triple mips64-unknown-unknown %s | \
+# RUN: llvm-mc -triple mips64-unknown-linux %s | \
 # RUN:   FileCheck -check-prefix=ALL -check-prefix=ASM %s
 
         .text
         .option pic2
 t1:
         .cpsetup $25, 8, __cerror
         nop
         .cpreturn

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 -mabi=n64 %s -o - \
 # RUN: | llvm-readobj -s | FileCheck --check-prefix=CHECK_64 %s
 # RUN: llvm-mc -filetype=obj -triple=mipsel %s -mabi=n32 -o - \
 # RUN: | llvm-readobj -s | FileCheck --check-prefix=CHECK_32 %s
 
 # Check for register information sections.
 #

test/MC/Mips/mips64-register-names-o32.s

 # RUN: llvm-mc %s -triple=mips64-unknown-freebsd -show-encoding \
 # RUN:     -mabi=o32 | FileCheck %s
 
 # Check that the register names are mapped to their correct numbers for o32
-# Second byte of daddiu with $zero at rt contains the number of the source
+# Second byte of addiu with $zero at rt contains the number of the source
 # register.
 
 .set noat
-daddiu  $zero, $zero, 0 # CHECK: encoding: [0x64,0x00,0x00,0x00]
-daddiu  $at, $zero, 0   # CHECK: encoding: [0x64,0x01,0x00,0x00]
-daddiu  $v0, $zero, 0   # CHECK: encoding: [0x64,0x02,0x00,0x00]
-daddiu  $v1, $zero, 0   # CHECK: encoding: [0x64,0x03,0x00,0x00]
-daddiu  $a0, $zero, 0   # CHECK: encoding: [0x64,0x04,0x00,0x00]
-daddiu  $a1, $zero, 0   # CHECK: encoding: [0x64,0x05,0x00,0x00]
-daddiu  $a2, $zero, 0   # CHECK: encoding: [0x64,0x06,0x00,0x00]
-daddiu  $a3, $zero, 0   # CHECK: encoding: [0x64,0x07,0x00,0x00]
-daddiu  $t0, $zero, 0   # CHECK: encoding: [0x64,0x08,0x00,0x00]
-daddiu  $t1, $zero, 0   # CHECK: encoding: [0x64,0x09,0x00,0x00]
-daddiu  $t2, $zero, 0   # CHECK: encoding: [0x64,0x0a,0x00,0x00]
-daddiu  $t3, $zero, 0   # CHECK: encoding: [0x64,0x0b,0x00,0x00]
-daddiu  $t4, $zero, 0   # CHECK: encoding: [0x64,0x0c,0x00,0x00]
-daddiu  $t5, $zero, 0   # CHECK: encoding: [0x64,0x0d,0x00,0x00]
-daddiu  $t6, $zero, 0   # CHECK: encoding: [0x64,0x0e,0x00,0x00]
-daddiu  $t7, $zero, 0   # CHECK: encoding: [0x64,0x0f,0x00,0x00]
-daddiu  $s0, $zero, 0   # CHECK: encoding: [0x64,0x10,0x00,0x00]
-daddiu  $s1, $zero, 0   # CHECK: encoding: [0x64,0x11,0x00,0x00]
-daddiu  $s2, $zero, 0   # CHECK: encoding: [0x64,0x12,0x00,0x00]
-daddiu  $s3, $zero, 0   # CHECK: encoding: [0x64,0x13,0x00,0x00]
-daddiu  $s4, $zero, 0   # CHECK: encoding: [0x64,0x14,0x00,0x00]
-daddiu  $s5, $zero, 0   # CHECK: encoding: [0x64,0x15,0x00,0x00]
-daddiu  $s6, $zero, 0   # CHECK: encoding: [0x64,0x16,0x00,0x00]
-daddiu  $s7, $zero, 0   # CHECK: encoding: [0x64,0x17,0x00,0x00]
-daddiu  $t8, $zero, 0   # CHECK: encoding: [0x64,0x18,0x00,0x00]
-daddiu  $t9, $zero, 0   # CHECK: encoding: [0x64,0x19,0x00,0x00]
-daddiu  $k0, $zero, 0   # CHECK: encoding: [0x64,0x1a,0x00,0x00]
-daddiu  $k1, $zero, 0   # CHECK: encoding: [0x64,0x1b,0x00,0x00]
-daddiu  $gp, $zero, 0   # CHECK: encoding: [0x64,0x1c,0x00,0x00]
-daddiu  $sp, $zero, 0   # CHECK: encoding: [0x64,0x1d,0x00,0x00]
-daddiu  $fp, $zero, 0   # CHECK: encoding: [0x64,0x1e,0x00,0x00]
-daddiu  $s8, $zero, 0   # CHECK: encoding: [0x64,0x1e,0x00,0x00]
-daddiu  $ra, $zero, 0   # CHECK: encoding: [0x64,0x1f,0x00,0x00]
+addiu  $zero, $zero, 0 # CHECK: encoding: [0x24,0x00,0x00,0x00]
+addiu  $at, $zero, 0   # CHECK: encoding: [0x24,0x01,0x00,0x00]
+addiu  $v0, $zero, 0   # CHECK: encoding: [0x24,0x02,0x00,0x00]
+addiu  $v1, $zero, 0   # CHECK: encoding: [0x24,0x03,0x00,0x00]
+addiu  $a0, $zero, 0   # CHECK: encoding: [0x24,0x04,0x00,0x00]
+addiu  $a1, $zero, 0   # CHECK: encoding: [0x24,0x05,0x00,0x00]
+addiu  $a2, $zero, 0   # CHECK: encoding: [0x24,0x06,0x00,0x00]
+addiu  $a3, $zero, 0   # CHECK: encoding: [0x24,0x07,0x00,0x00]
+addiu  $t0, $zero, 0   # CHECK: encoding: [0x24,0x08,0x00,0x00]
+addiu  $t1, $zero, 0   # CHECK: encoding: [0x24,0x09,0x00,0x00]
+addiu  $t2, $zero, 0   # CHECK: encoding: [0x24,0x0a,0x00,0x00]
+addiu  $t3, $zero, 0   # CHECK: encoding: [0x24,0x0b,0x00,0x00]
+addiu  $t4, $zero, 0   # CHECK: encoding: [0x24,0x0c,0x00,0x00]
+addiu  $t5, $zero, 0   # CHECK: encoding: [0x24,0x0d,0x00,0x00]
+addiu  $t6, $zero, 0   # CHECK: encoding: [0x24,0x0e,0x00,0x00]
+addiu  $t7, $zero, 0   # CHECK: encoding: [0x24,0x0f,0x00,0x00]
+addiu  $s0, $zero, 0   # CHECK: encoding: [0x24,0x10,0x00,0x00]
+addiu  $s1, $zero, 0   # CHECK: encoding: [0x24,0x11,0x00,0x00]
+addiu  $s2, $zero, 0   # CHECK: encoding: [0x24,0x12,0x00,0x00]
+addiu  $s3, $zero, 0   # CHECK: encoding: [0x24,0x13,0x00,0x00]
+addiu  $s4, $zero, 0   # CHECK: encoding: [0x24,0x14,0x00,0x00]
+addiu  $s5, $zero, 0   # CHECK: encoding: [0x24,0x15,0x00,0x00]
+addiu  $s6, $zero, 0   # CHECK: encoding: [0x24,0x16,0x00,0x00]
+addiu  $s7, $zero, 0   # CHECK: encoding: [0x24,0x17,0x00,0x00]
+addiu  $t8, $zero, 0   # CHECK: encoding: [0x24,0x18,0x00,0x00]
+addiu  $t9, $zero, 0   # CHECK: encoding: [0x24,0x19,0x00,0x00]
+addiu  $k0, $zero, 0   # CHECK: encoding: [0x24,0x1a,0x00,0x00]
+addiu  $k1, $zero, 0   # CHECK: encoding: [0x24,0x1b,0x00,0x00]
+addiu  $gp, $zero, 0   # CHECK: encoding: [0x24,0x1c,0x00,0x00]
+addiu  $sp, $zero, 0   # CHECK: encoding: [0x24,0x1d,0x00,0x00]
+addiu  $fp, $zero, 0   # CHECK: encoding: [0x24,0x1e,0x00,0x00]
+addiu  $s8, $zero, 0   # CHECK: encoding: [0x24,0x1e,0x00,0x00]
+addiu  $ra, $zero, 0   # CHECK: encoding: [0x24,0x1f,0x00,0x00]

tools/llc/llc.cpp

static int compileModule(char **argv, LLVMContext &Context) {
   case '3': OLvl = CodeGenOpt::Aggressive; break;
   }
 
   TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
   Options.DisableIntegratedAS = NoIntegratedAssembler;
   Options.MCOptions.ShowMCEncoding = ShowMCEncoding;
   Options.MCOptions.MCUseDwarfDirectory = EnableDwarfDirectory;
   Options.MCOptions.AsmVerbose = AsmVerbose;
+
+  // Adjust the triple if we can. Otherwise put the ABI name in
+  // MCTargetOptions::ABIName.
+  Triple TT = TheTriple.getABIVariant(MABI);
+  if (TT.getArch() == Triple::UnknownArch)
     Options.MCOptions.ABIName = MABI;
+  else
+    TheTriple = TT;
 
   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

tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
 
   setDwarfDebugProducer();
 
   const char *ProgName = argv[0];
   const Target *TheTarget = GetTarget(ProgName);
   if (!TheTarget)
     return 1;
 
+  // Adjust the triple if we can. Otherwise put the ABI name in
+  // MCTargetOptions::ABIName.
   MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();
+  Triple TT = Triple(TripleName).getABIVariant(MABI);
+  if (TT.getArch() == Triple::UnknownArch)
     MCOptions.ABIName = MABI;
+  else
+    TripleName = TT.str();
 
   // Now that GetTarget() has (potentially) replaced TripleName, it's safe to
   // construct the Triple object.
   Triple TheTriple(TripleName);
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(InputFilename);
   if (std::error_code EC = BufferPtr.getError()) {

unittests/ADT/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
   T = Triple("amdgcn-amd-amdhsa");
   EXPECT_EQ(Triple::amdgcn, T.getArch());
   EXPECT_EQ(Triple::AMD, T.getVendor());
   EXPECT_EQ(Triple::AMDHSA, 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;
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("").getArch());
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("32").getArch());
+
+  T.setArch(Triple::UnknownArch);
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("").getArch());
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("32").getArch());
+
+  // Try a triple that doesn't support getABIVariant().
+  T = Triple("x86_64-pc-linux-gnu");
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("").getArch());
+  EXPECT_EQ(Triple::UnknownArch, T.getABIVariant("32").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));
+    Triple Default = T.getABIVariant("");
+    Triple O32 = T.getABIVariant("o32");
+    Triple N32 = T.getABIVariant("n32");
+    Triple N64 = T.getABIVariant("n64");
+    Triple Foo = T.getABIVariant("foo");
+
+    EXPECT_EQ(T.getArch(), Default.getArch());
+    EXPECT_EQ(T.get32BitArchVariant().getArch(), O32.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N32.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N64.getArch());
+    EXPECT_EQ(Triple::UnknownArch, Foo.getArch());
+
+    EXPECT_EQ(T.getVendor(), Default.getVendor());
+    EXPECT_EQ(T.getVendor(), O32.getVendor());
+    EXPECT_EQ(T.getVendor(), N32.getVendor());
+    EXPECT_EQ(T.getVendor(), N64.getVendor());
+
+    EXPECT_EQ(T.getOS(), Default.getOS());
+    EXPECT_EQ(T.getOS(), O32.getOS());
+    EXPECT_EQ(T.getOS(), N32.getOS());
+    EXPECT_EQ(T.getOS(), N64.getOS());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? Triple::GNUABI64
+                  : Triple::GNUABI32,
+              Default.getEnvironment());
+    EXPECT_EQ(Triple::GNUABI32, O32.getEnvironment());
+    EXPECT_EQ(Triple::GNUABIN32, N32.getEnvironment());
+    EXPECT_EQ(Triple::GNUABI64, N64.getEnvironment());
+  }
+
+  for (const auto &TripleStr :
+       {"mipsel-linux-android", "mips64el-linux-android"}) {
+    T = Triple(Triple::normalize(TripleStr));
+    Triple Default = T.getABIVariant("");
+    Triple O32 = T.getABIVariant("o32");
+    Triple N32 = T.getABIVariant("n32");
+    Triple N64 = T.getABIVariant("n64");
+    Triple Foo = T.getABIVariant("foo");
+
+    EXPECT_EQ(T.getArch(), Default.getArch());
+    EXPECT_EQ(T.get32BitArchVariant().getArch(), O32.getArch());
+    EXPECT_EQ(Triple::UnknownArch, N32.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N64.getArch());
+    EXPECT_EQ(Triple::UnknownArch, Foo.getArch());
+
+    EXPECT_EQ(T.getVendor(), Default.getVendor());
+    EXPECT_EQ(T.getVendor(), O32.getVendor());
+    EXPECT_EQ(T.getVendor(), N64.getVendor());
+
+    EXPECT_EQ(T.getOS(), Default.getOS());
+    EXPECT_EQ(T.getOS(), O32.getOS());
+    EXPECT_EQ(T.getOS(), N64.getOS());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? Triple::AndroidABI64
+                  : Triple::AndroidABI32,
+              Default.getEnvironment());
+    EXPECT_EQ(Triple::AndroidABI32, O32.getEnvironment());
+    EXPECT_EQ(Triple::AndroidABI64, N64.getEnvironment());
+  }
+
+  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));
+    Triple Default = T.getABIVariant("");
+    Triple O32 = T.getABIVariant("o32");
+    Triple N32 = T.getABIVariant("n32");
+    Triple N64 = T.getABIVariant("n64");
+    Triple Foo = T.getABIVariant("foo");
+
+    EXPECT_EQ(T.getArch(), Default.getArch());
+    EXPECT_EQ(T.get32BitArchVariant().getArch(), O32.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N32.getArch());
+    EXPECT_EQ(T.get64BitArchVariant().getArch(), N64.getArch());
+    EXPECT_EQ(Triple::UnknownArch, Foo.getArch());
+
+    EXPECT_EQ(T.getVendor(), Default.getVendor());
+    EXPECT_EQ(T.getVendor(), O32.getVendor());
+    EXPECT_EQ(T.getVendor(), N32.getVendor());
+    EXPECT_EQ(T.getVendor(), N64.getVendor());
+
+    EXPECT_EQ(T.getOS(), Default.getOS());
+    EXPECT_EQ(T.getOS(), O32.getOS());
+    EXPECT_EQ(T.getOS(), N32.getOS());
+    EXPECT_EQ(T.getOS(), N64.getOS());
+
+    EXPECT_EQ((T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
+                  ? Triple::ABI64
+                  : Triple::ABI32,
+              Default.getEnvironment());
+    EXPECT_EQ(Triple::ABI32, O32.getEnvironment());
+    EXPECT_EQ(Triple::ABIN32, N32.getEnvironment());
+    EXPECT_EQ(Triple::ABI64, N64.getEnvironment());
+  }
+}
+
 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());