[Clang][LoongArch] Pass the -mabi and -target-abi options to as and cc1as respectively

[SixWeining]

Summary

This change is necessary to set correct EFlags according to the
options (-m*-float and -mabi=) passed to clang when input is assembly.

Note: -mabi= is not documented by as.

$ as --version
GNU assembler (GNU Binutils) 2.40.50.20230316
...
$ as --target-help
LARCH options:

But we can see gcc invokes as and passes the -mabi= option when compiling C or assembly.

$ gcc -c a.c -v 2>&1 -msoft-float | grep "as -v"
 as -v -mabi=lp64s -o a.o /tmp/ccFrxzZi.s
$ gcc -c a.s -v 2>&1 -msoft-float | grep "as -v"
 as -v -mabi=lp64s -o a.o a.s

clang/lib/Driver/ToolChains/Clang.h

void ConstructJob(Compilation &C, const JobAction &JA,
                     const char *LinkingOutput) const override;
 };
 
 /// Clang integrated assembler tool.
 class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
 public:
   ClangAs(const ToolChain &TC)
       : Tool("clang::as", "clang integrated assembler", TC) {}
+  void AddLoongArchTargetArgs(const llvm::opt::ArgList &Args,
+                              llvm::opt::ArgStringList &CmdArgs) const;
   void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
                          llvm::opt::ArgStringList &CmdArgs) const;
   void AddX86TargetArgs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const;
   void AddRISCVTargetArgs(const llvm::opt::ArgList &Args,
                           llvm::opt::ArgStringList &CmdArgs) const;
   bool hasGoodDiagnostics() const override { return true; }
   bool hasIntegratedAssembler() const override { return false; }

clang/lib/Driver/ToolChains/Clang.cpp

if (Value == "intel" || Value == "att") {
       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
     } else {
       getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
           << A->getSpelling() << Value;
     }
   }
 }
 
+void ClangAs::AddLoongArchTargetArgs(const ArgList &Args,
+                                     ArgStringList &CmdArgs) const {
+  CmdArgs.push_back("-target-abi");
+  CmdArgs.push_back(loongarch::getLoongArchABI(getToolChain().getDriver(), Args,
+                                               getToolChain().getTriple())
+                        .data());
+}
+
 void ClangAs::AddRISCVTargetArgs(const ArgList &Args,
                                ArgStringList &CmdArgs) const {
   const llvm::Triple &Triple = getToolChain().getTriple();
   StringRef ABIName = riscv::getRISCVABI(Args, Triple);
 
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName.data());
 
void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
   case llvm::Triple::aarch64_32:
   case llvm::Triple::aarch64_be:
     if (Args.hasArg(options::OPT_mmark_bti_property)) {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-aarch64-mark-bti-property");
     }
     break;
 
+  case llvm::Triple::loongarch32:
+  case llvm::Triple::loongarch64:
+    AddLoongArchTargetArgs(Args, CmdArgs);
+    break;
+
   case llvm::Triple::riscv32:
   case llvm::Triple::riscv64:
     AddRISCVTargetArgs(Args, CmdArgs);
     break;
   }
 
   // Consume all the warning flags. Usually this would be handled more
   // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as

clang/lib/Driver/ToolChains/Gnu.cpp

 //===--- Gnu.cpp - Gnu Tool and ToolChain Implementations -------*- C++ -*-===//
 //
 // 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 "Gnu.h"
 #include "Arch/ARM.h"
 #include "Arch/CSKY.h"
+#include "Arch/LoongArch.h"
 #include "Arch/Mips.h"
 #include "Arch/PPC.h"
 #include "Arch/RISCV.h"
 #include "Arch/Sparc.h"
 #include "Arch/SystemZ.h"
 #include "CommonArgs.h"
 #include "Linux.h"
 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
void tools::gnutools::Assembler::ConstructJob(Compilation &C,
   case llvm::Triple::aarch64_be: {
     CmdArgs.push_back(
         getToolChain().getArch() == llvm::Triple::aarch64_be ? "-EB" : "-EL");
     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
     normalizeCPUNamesForAssembler(Args, CmdArgs);
 
     break;
   }
+  // TODO: handle loongarch32.
+  case llvm::Triple::loongarch64: {
+    StringRef ABIName =
+        loongarch::getLoongArchABI(D, Args, getToolChain().getTriple());
+    CmdArgs.push_back(Args.MakeArgString("-mabi=" + ABIName));
+    break;
+  }
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el: {
     StringRef CPUName;
     StringRef ABIName;
     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
     ABIName = mips::getGnuCompatibleMipsABIName(ABIName);

clang/test/Driver/loongarch-as.s

+/// This file checks options are correctly passed to as for LoongArch targets.
+
+/// Check `-mabi`.
+// RUN: %clang --target=loongarch64 -### -fno-integrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=lp64d --check-prefix=ABI %s
+// RUN: %clang --target=loongarch64 -mabi=lp64d -### -fno-integrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=lp64d --check-prefix=ABI %s
+// RUN: %clang --target=loongarch64 -mabi=lp64f -### -fno-integrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=lp64f --check-prefix=ABI %s
+// RUN: %clang --target=loongarch64 -mabi=lp64s -### -fno-integrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=lp64s --check-prefix=ABI %s
+
+// ALL: as
+
+// ABI: "-mabi=[[ABI]]"

clang/test/Driver/loongarch-ias.s

+/// This file checks options are correctly passed to cc1as for LoongArch targets.
+
+/// Check `-target-abi`.
+// RUN: %clang --target=loongarch32 -### -fintegrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=ilp32d --check-prefix=ABI %s
+// RUN: %clang --target=loongarch32 -mabi=ilp32d -### -fintegrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=ilp32d --check-prefix=ABI %s
+// RUN: %clang --target=loongarch32 -mabi=ilp32f -### -fintegrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=ilp32f --check-prefix=ABI %s
+// RUN: %clang --target=loongarch32 -mabi=ilp32s -### -fintegrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=ilp32s --check-prefix=ABI %s
+// RUN: %clang --target=loongarch64 -### -fintegrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=lp64d --check-prefix=ABI %s
+// RUN: %clang --target=loongarch64 -mabi=lp64d -### -fintegrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=lp64d --check-prefix=ABI %s
+// RUN: %clang --target=loongarch64 -mabi=lp64f -### -fintegrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=lp64f --check-prefix=ABI %s
+// RUN: %clang --target=loongarch64 -mabi=lp64s -### -fintegrated-as -c %s 2>&1 | \
+// RUN:   FileCheck -DABI=lp64s --check-prefix=ABI %s
+
+// ALL: -cc1as
+
+// ABI: "-target-abi" "[[ABI]]"