Pass the ABI in the triple when appropriate (currently for MIPS) for 'clang -cc1' and 'clang -cc1as'

[sdardis]

Summary

'clang -cc1' and 'clang -cc1as' will mutate the triple to account for
-target-abi if such a conversion is defined by Triple::getABIVariant().
Otherwise, the ABI will continue to be passed via MCTargetOptions::ABIName.

Additionally, 'clang -cc1as' now applies the effect of -target-abi. Previously
it was ignored.

Patch by: Daniel Sanders

[dsanders]

Updated to match latest version of D21467.

At this point Mips is in the X86/everyone-else camp but there's a loose end to
tie up in LLVM in order to prove it. Once LLVM rejects non-empty ABIName's
for Mips, we have proven we're in the X86/everyone-else camp and can start
uniting the Mips/X86/everyone-else camp with the ARM/PowerPC camp.

[dsanders]

Refresh and ping

[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]

Ping.

[sdardis]

Rebase and ping.

lib/Basic/Targets.cpp

public:
   MipsTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
       : 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().getEnvironment() == llvm::Triple::ABI32 ||
+        getTriple().getEnvironment() == llvm::Triple::GNUABI32 ||
+        getTriple().getEnvironment() == llvm::Triple::AndroidABI32)
+      setABI("o32");
+    else if (getTriple().getEnvironment() == llvm::Triple::ABIN32 ||
+        getTriple().getEnvironment() == llvm::Triple::GNUABIN32)
+      setABI("n32");
+    else if (getTriple().getEnvironment() == llvm::Triple::ABI64 ||
+             getTriple().getEnvironment() == llvm::Triple::GNUABI64 ||
+             getTriple().getEnvironment() == llvm::Triple::AndroidABI64)
+      setABI("n64");
+    else
       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 processorSupportsGPR64() const {
     return false;
   }
 
   StringRef getABI() const override { return ABI; }
   bool setABI(const std::string &Name) override {
     if (Name == "o32") {
       setO32ABITypes();
       ABI = Name;
+      setDataLayout();
       return true;
     }
 
     if (Name == "n32") {
       setN32ABITypes();
       ABI = Name;
+      setDataLayout();
       return true;
     }
     if (Name == "n64") {
       setN64ABITypes();
       ABI = Name;
+      setDataLayout();
       return true;
     }
     return false;
   }
 
   void setO32ABITypes() {
     Int64Type = SignedLongLong;
     IntMaxType = Int64Type;

lib/Driver/ToolChains.cpp

for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
         return true;
       }
     }
     return false;
   }
 
   if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
       TargetTriple.getOS() == llvm::Triple::Linux &&
-      TargetTriple.getEnvironment() == llvm::Triple::GNU) {
+      TargetTriple.isGNUEnvironment()) {
     // Select mips-img-linux-gnu toolchain.
     for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
       if (Candidate->select(Flags, Result.SelectedMultilib)) {
         Result.Multilibs = *Candidate;
         return true;
       }
     }
     return false;

lib/Driver/Tools.cpp

 void mips::getMipsCPUAndABI(const ArgList &Args, const llvm::Triple &Triple,
                             StringRef &CPUName, StringRef &ABIName) {
   const char *DefMips32CPU = "mips32r2";
   const char *DefMips64CPU = "mips64r2";
 
   // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
   // default for mips64(el)?-img-linux-gnu.
   if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
-      Triple.getEnvironment() == llvm::Triple::GNU) {
+      Triple.isGNUEnvironment()) {
     DefMips32CPU = "mips32r6";
     DefMips64CPU = "mips64r6";
   }
 
   // MIPS64r6 is the default for Android MIPS64 (mips64el-linux-android).
   if (Triple.isAndroid()) {
     DefMips32CPU = "mips32";
     DefMips64CPU = "mips64r6";

lib/Frontend/CompilerInvocation.cpp

static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
   Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
   Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
   Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
   Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
   Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
   // Use the default target triple if unspecified.
   if (Opts.Triple.empty())
     Opts.Triple = llvm::sys::getDefaultTargetTriple();
+
+  // Pass the ABI in the triple if the target prefers this, otherwise
+  // pass it in Opts.ABI.
+  llvm::Triple ABITriple = llvm::Triple(Opts.Triple).getABIVariant(Opts.ABI);
+  if (ABITriple.getArch() != llvm::Triple::UnknownArch) {
+    Opts.Triple = ABITriple.str();
+    Opts.ABI = "";
+  }
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
                                         const char *const *ArgBegin,
                                         const char *const *ArgEnd,
                                         DiagnosticsEngine &Diags) {
   bool Success = true;
 

tools/driver/cc1as_main.cpp

 /// \brief Helper class for representing a single invocation of the assembler.
 struct AssemblerInvocation {
   /// @name Target Options
   /// @{
 
   /// The name of the target triple to assemble for.
   std::string Triple;
 
+  /// The name of the ABI to assembler for or the empty string for the default
+  /// ABI.
+  std::string ABI;
+
   /// If given, the name of the target CPU to determine which instructions
   /// are legal.
   std::string CPU;
 
   /// The list of target specific features to enable or disable -- this should
   /// be a list of strings starting with '+' or '-'.
   std::vector<std::string> Features;
 
struct AssemblerInvocation {
   /// The name of the relocation model to use.
   std::string RelocationModel;
 
   /// @}
 
 public:
   AssemblerInvocation() {
     Triple = "";
+    ABI = "";
     NoInitialTextSection = 0;
     InputFile = "-";
     OutputPath = "-";
     OutputType = FT_Asm;
     OutputAsmVariant = 0;
     ShowInst = 0;
     ShowEncoding = 0;
     RelaxAll = 0;
for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
     Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args);
     Success = false;
   }
 
   // Construct the invocation.
 
   // Target Options
   Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
+  Opts.ABI = Args.getLastArgValue(OPT_target_abi);
   Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
   Opts.Features = Args.getAllArgValues(OPT_target_feature);
 
   // Use the default target triple if unspecified.
   if (Opts.Triple.empty())
     Opts.Triple = llvm::sys::getDefaultTargetTriple();
 
+  llvm::Triple ABITriple = llvm::Triple(Opts.Triple).getABIVariant(Opts.ABI);
+  if (ABITriple.getArch() != llvm::Triple::UnknownArch) {
+    Opts.Triple = ABITriple.str();
+    Opts.ABI = "";
+  }
+
   // Language Options
   Opts.IncludePaths = Args.getAllArgValues(OPT_I);
   Opts.NoInitialTextSection = Args.hasArg(OPT_n);
   Opts.SaveTemporaryLabels = Args.hasArg(OPT_msave_temp_labels);
   // Any DebugInfoKind implies GenDwarfForAssembly.
   Opts.GenDwarfForAssembly = Args.hasArg(OPT_debug_info_kind_EQ);
   Opts.CompressDebugSections = Args.hasArg(OPT_compress_debug_sections);
   Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);