[mips] Replace almost all Arch checks in MipsTargetInfo with ABI checks. NFC.

[dsanders]

Summary

setABI() is still tied to the Arch component of the Triple to preserve existing
behaviour.

[atanasyan]

LGTM

lib/Basic/Targets.cpp

class MipsTargetInfo : public TargetInfo {
   bool HasMSA;
 
 protected:
   bool HasFP64;
   std::string ABI;
 
 public:
   MipsTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
-      : TargetInfo(Triple), CPU((getTriple().getArch() == llvm::Triple::mips ||
-                                 getTriple().getArch() == llvm::Triple::mipsel)
-                                    ? "mips32r2"
-                                    : "mips64r2"),
-        IsMips16(false), IsMicromips(false), IsNan2008(false),
-        IsSingleFloat(false), FloatABI(HardFloat), DspRev(NoDSP), HasMSA(false),
-        HasFP64(false), ABI((getTriple().getArch() == llvm::Triple::mips ||
-                             getTriple().getArch() == llvm::Triple::mipsel)
-                                ? "o32"
-                                : "n64") {
+      : TargetInfo(Triple), IsMips16(false), IsMicromips(false),
+        IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
+        DspRev(NoDSP), HasMSA(false), HasFP64(false) {
     TheCXXABI.set(TargetCXXABI::GenericMIPS);
     BigEndian = getTriple().getArch() == llvm::Triple::mips ||
                 getTriple().getArch() == llvm::Triple::mips64;
 
-    if (getTriple().getArch() == llvm::Triple::mips ||
-        getTriple().getArch() == llvm::Triple::mipsel) {
-      SizeType = UnsignedInt;
-      PtrDiffType = SignedInt;
-      Int64Type = SignedLongLong;
-      IntMaxType = Int64Type;
-      MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
-    } else {
-      LongDoubleWidth = LongDoubleAlign = 128;
-      LongDoubleFormat = &llvm::APFloat::IEEEquad;
-      if (getTriple().getOS() == llvm::Triple::FreeBSD) {
-        LongDoubleWidth = LongDoubleAlign = 64;
-        LongDoubleFormat = &llvm::APFloat::IEEEdouble;
-      }
-      setN64ABITypes();
-      SuitableAlign = 128;
-      MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
-    }
+    setABI((getTriple().getArch() == llvm::Triple::mips ||
+            getTriple().getArch() == llvm::Triple::mipsel)
+               ? "o32"
+               : "n64");
+
+    CPU = ABI == "o32" ? "mips32r2" : "mips64r2";
   }
 
   bool isNaN2008Default() const {
     return CPU == "mips32r6" || CPU == "mips64r6";
   }
 
   bool isFP64Default() const {
     return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
   }
 
   bool isNan2008() const override {
     return IsNan2008;
   }
 
   StringRef getABI() const override { return ABI; }
   bool setABI(const std::string &Name) override {
+    // FIXME: The Arch component on the triple actually has no bearing on
+    //        whether the ABI is valid or not. It's features of the CPU that
+    //        matters and the size of the GPR's in particular.
+    //        However, we can't allow O32 on 64-bit processors just yet because
+    //        the backend still checks the Arch component instead of the ABI in
+    //        a few places.
     if (getTriple().getArch() == llvm::Triple::mips ||
         getTriple().getArch() == llvm::Triple::mipsel) {
       if (Name == "o32") {
+        setO32ABITypes();
         ABI = Name;
         return true;
       }
     }
     if (getTriple().getArch() == llvm::Triple::mips64 ||
         getTriple().getArch() == llvm::Triple::mips64el) {
       if (Name == "n32") {
         setN32ABITypes();
         ABI = Name;
         return true;
       }
       if (Name == "n64") {
         setN64ABITypes();
         ABI = Name;
         return true;
       }
     }
     return false;
   }
 
+  void setO32ABITypes() {
+    Int64Type = SignedLongLong;
+    IntMaxType = Int64Type;
+    LongDoubleFormat = &llvm::APFloat::IEEEdouble;
+    LongDoubleWidth = LongDoubleAlign = 64;
+    LongWidth = LongAlign = 32;
+    MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
+    PointerWidth = PointerAlign = 32;
+    PtrDiffType = SignedInt;
+    SizeType = UnsignedInt;
+    SuitableAlign = 64;
+  }
+
+  void setN32N64ABITypes() {
+    LongDoubleWidth = LongDoubleAlign = 128;
+    LongDoubleFormat = &llvm::APFloat::IEEEquad;
+    if (getTriple().getOS() == llvm::Triple::FreeBSD) {
+      LongDoubleWidth = LongDoubleAlign = 64;
+      LongDoubleFormat = &llvm::APFloat::IEEEdouble;
+    }
+    MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
+    SuitableAlign = 128;
+  }
+
   void setN64ABITypes() {
+    setN32N64ABITypes();
+    Int64Type = SignedLong;
+    IntMaxType = Int64Type;
     LongWidth = LongAlign = 64;
     PointerWidth = PointerAlign = 64;
-    SizeType = UnsignedLong;
     PtrDiffType = SignedLong;
-    Int64Type = SignedLong;
-    IntMaxType = Int64Type;
+    SizeType = UnsignedLong;
   }
 
   void setN32ABITypes() {
+    setN32N64ABITypes();
+    Int64Type = SignedLongLong;
+    IntMaxType = Int64Type;
     LongWidth = LongAlign = 32;
     PointerWidth = PointerAlign = 32;
-    SizeType = UnsignedInt;
     PtrDiffType = SignedInt;
-    Int64Type = SignedLongLong;
-    IntMaxType = Int64Type;
+    SizeType = UnsignedInt;
   }
 
   bool setCPU(const std::string &Name) override {
-    bool IsMips32 = getTriple().getArch() == llvm::Triple::mips ||
-                    getTriple().getArch() == llvm::Triple::mipsel;
+    bool GPR64Required = ABI == "n32" || ABI == "n64";
     CPU = Name;
     return llvm::StringSwitch<bool>(Name)
-        .Case("mips1", IsMips32)
-        .Case("mips2", IsMips32)
+        .Case("mips1", !GPR64Required)
+        .Case("mips2", !GPR64Required)
         .Case("mips3", true)
         .Case("mips4", true)
         .Case("mips5", true)
-        .Case("mips32", IsMips32)
-        .Case("mips32r2", IsMips32)
-        .Case("mips32r3", IsMips32)
-        .Case("mips32r5", IsMips32)
-        .Case("mips32r6", IsMips32)
+        .Case("mips32", !GPR64Required)
+        .Case("mips32r2", !GPR64Required)
+        .Case("mips32r3", !GPR64Required)
+        .Case("mips32r5", !GPR64Required)
+        .Case("mips32r6", !GPR64Required)
         .Case("mips64", true)
         .Case("mips64r2", true)
         .Case("mips64r3", true)
         .Case("mips64r5", true)
         .Case("mips64r6", true)
         .Case("octeon", true)
         .Case("p5600", true)
         .Default(false);
if (BigEndian) {
       Builder.defineMacro("_MIPSEL");
     }
 
     Builder.defineMacro("__mips__");
     Builder.defineMacro("_mips");
     if (Opts.GNUMode)
       Builder.defineMacro("mips");
 
-    if (getTriple().getArch() == llvm::Triple::mips ||
-        getTriple().getArch() == llvm::Triple::mipsel) {
+    if (ABI == "o32") {
       Builder.defineMacro("__mips", "32");
       Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32");
     } else {
       Builder.defineMacro("__mips", "64");
       Builder.defineMacro("__mips64");
       Builder.defineMacro("__mips64__");
       Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64");
     }
void getTargetDefines(const LangOptions &Opts,
     Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
     Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
 
     // These shouldn't be defined for MIPS-I but there's no need to check
     // for that since MIPS-I isn't supported.
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
-    if (getTriple().getArch() == llvm::Triple::mips64 ||
-        getTriple().getArch() == llvm::Triple::mips64el)
+
+    // 32-bit MIPS processors don't have the necessary lld/scd instructions
+    // found in 64-bit processors. In the case of O32 on a 64-bit processor,
+    // the instructions exist but using them violates the ABI since they
+    // require 64-bit GPRs and O32 only supports 32-bit GPRs.
+    if (ABI == "n32" || ABI == "n64")
       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
   }
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return llvm::makeArrayRef(BuiltinInfo,
                           clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin);
   }
   bool hasFeature(StringRef Feature) const override {
static const TargetInfo::GCCRegAlias NewABIRegAliases[] = {
         {{"a6"}, "$10"}, {{"a7"}, "$11"},        {{"t0"}, "$12"},
         {{"t1"}, "$13"}, {{"t2"}, "$14"},        {{"t3"}, "$15"},
         {{"s0"}, "$16"}, {{"s1"}, "$17"},        {{"s2"}, "$18"},
         {{"s3"}, "$19"}, {{"s4"}, "$20"},        {{"s5"}, "$21"},
         {{"s6"}, "$22"}, {{"s7"}, "$23"},        {{"t8"}, "$24"},
         {{"t9"}, "$25"}, {{"k0"}, "$26"},        {{"k1"}, "$27"},
         {{"gp"}, "$28"}, {{"sp", "$sp"}, "$29"}, {{"fp", "$fp"}, "$30"},
         {{"ra"}, "$31"}};
-    if (getTriple().getArch() == llvm::Triple::mips ||
-        getTriple().getArch() == llvm::Triple::mipsel)
+    if (ABI == "o32")
       return llvm::makeArrayRef(O32RegAliases);
     return llvm::makeArrayRef(NewABIRegAliases);
   }
 
   bool hasInt128Type() const override {
-    return getTriple().getArch() == llvm::Triple::mips64 ||
-           getTriple().getArch() == llvm::Triple::mips64el;
+    return ABI == "n32" || ABI == "n64";
   }
 };
 
 const Builtin::Info MipsTargetInfo::BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS) \
   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },