[Clang][Driver] Handle LoongArch multiarch tuples

[xen0n]

Summary

This follows v1.00 of the LoongArch Toolchain Conventions,
but notably with this patch
applied (a proper version bump to v2.00 was not done, so it is
indistinguishable from the "original" but now incompatible v1.00
otherwise).

Only loongarch64 is implemented in Linux::getMultiarchTriple
because support for LA32 and ILP32* ABIs are incomplete right now.

The Debian sysroot layout is based on Han Gao's recent porting effort,
specifically the ghcr.io/rabenda/beige:loong64-v23-preview-20230330
container image.

[SixWeining]

clang/lib/Driver/ToolChains/Linux.cpp

41

Missing test. Perhaps add some in clang/test/Driver/linux-ld.c and clang/test/Driver/linux-header-search.cpp? Or postpone this change until loongarch is upstreamed to Debian?

93

Should only check {GNU|GNUF32|GNUF64}?

95

Should only check Triple::Musl?

[MaskRay]

clang/lib/Driver/ToolChains/Linux.cpp

116

return (... + ...).str(); if an operand of + is a Twine

[xen0n]

rebase

[xen0n]

clang/lib/Driver/ToolChains/Linux.cpp

41

Thanks, I'll try adding the tests in the next revision.

But given the recent reversal of upstream dpkg support (apparently due to miscommunication) it may be prudent to wait until a consensus is reached Debian-side.

93

While technically only gnu{,sf,f32,f64} are permitted by the LoongArch Toolchain Conventions (with the bare -gnu being somewhat de-facto standard but not officially so), I believe the user's intent to specify a GNU environment still holds even in cases of "errors" like applying "gnuabi64" or "gnueabi" to LoongArch. Same applies for the musl case.

95

Explained above in the GNU case.

116

Thanks, will change in next revision.

[SixWeining]

clang/lib/Driver/ToolChains/Arch/LoongArch.cpp

66

Better to be f? (Probably most 32-bit hardwares do not support double-float? But I'm not sure about this.)

clang/lib/Driver/ToolChains/Linux.cpp

41

The multiarch tuples have been upstreamed to dpkg. I think we can amend the change and move on now.

[xry111]

clang/lib/Driver/ToolChains/Arch/LoongArch.cpp

66

The ISA manual says 64-bit float support is not limited by 32-bit basic ISA support (except the moving instructions accessing 64-bit GPR).

[xen0n]

Rebase and reflect the Toolchain Conventions change.

[xen0n]

clang/lib/Driver/ToolChains/Arch/LoongArch.cpp

66

AFAIK the consensus (even inside Loongson) is that even LA32's unmarked/default ABI is going to have hard F64 available. And yes the ISA manual is consistent with this view too. (IMO LA32 should instead default to soft-float, but if Loongson's commercial roadmap can guarantee hardware FPU availability on all meaningful LA32 models then that would backfire, who knows...)

clang/lib/Driver/ToolChains/Linux.cpp

41

Sorry for the delay in processing this, I've updated the code to reflect the latest spec change. I'll still have to check the unit-test part though.

[xen0n]

Rebase and add tests, also use Twine for concatenating strings

[xen0n]

clang/lib/Driver/ToolChains/Linux.cpp

41

I've now added tests for the Debian sysroot layout, based on Revy's latest work.

[SixWeining]

clang/test/Driver/linux-header-search.cpp

247 ↗

(On Diff #510333)

Better to use “loongarch64” when talking about debian? Refer https://wiki.debian.org/Multiarch/Tuples

252 ↗

(On Diff #510333)

Use LA64 instead of LOONG64?

[xen0n]

clang/test/Driver/linux-header-search.cpp

247 ↗

(On Diff #510333)

It's the dpkg arch identifier and actually the port's official name. I chose it because it's shorter. Do we still want to emphasize the target tuple instead of the distro identity in this case?

252 ↗

(On Diff #510333)

Similarly I meant to refer to the Debian port name here.

[SixWeining]

clang/test/Driver/linux-header-search.cpp

247 ↗

(On Diff #510333)

Sorry I didn’t noticed this before. Now it LGTM. Thanks.

clang/lib/Driver/ToolChains/Arch/LoongArch.cpp

if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
     if (FPU == "32")
       return IsLA32 ? "ilp32f" : "lp64f";
     if (FPU == "0" || FPU == "none")
       return IsLA32 ? "ilp32s" : "lp64s";
     D.Diag(diag::err_drv_loongarch_invalid_mfpu_EQ) << FPU;
   }
 
   // Choose a default based on the triple.
+  // Honor the explicit ABI modifier suffix in triple's environment part if
+  // present, falling back to {ILP32,LP64}D otherwise.
+  switch (Triple.getEnvironment()) {
+  case llvm::Triple::GNUSF:
+    return IsLA32 ? "ilp32s" : "lp64s";
+  case llvm::Triple::GNUF32:
+    return IsLA32 ? "ilp32f" : "lp64f";
+  case llvm::Triple::GNUF64:
+  default:
     return IsLA32 ? "ilp32d" : "lp64d";
   }
+}
 
 void loongarch::getLoongArchTargetFeatures(const Driver &D,
                                            const llvm::Triple &Triple,
                                            const ArgList &Args,
                                            std::vector<StringRef> &Features) {
   StringRef ArchName;
   llvm::LoongArch::ArchKind ArchKind = llvm::LoongArch::ArchKind::AK_INVALID;
   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {

clang/lib/Driver/ToolChains/Linux.cpp

 using tools::addPathIfExists;
 
 /// Get our best guess at the multiarch triple for a target.
 ///
 /// Debian-based systems are starting to use a multiarch setup where they use
 /// a target-triple directory in the library and header search paths.
 /// Unfortunately, this triple does not align with the vanilla target triple,
 /// so we provide a rough mapping here.
 std::string Linux::getMultiarchTriple(const Driver &D,
                                       const llvm::Triple &TargetTriple,
                                       StringRef SysRoot) const {
   llvm::Triple::EnvironmentType TargetEnvironment =
       TargetTriple.getEnvironment();
   bool IsAndroid = TargetTriple.isAndroid();
   bool IsMipsR6 = TargetTriple.getSubArch() == llvm::Triple::MipsSubArch_r6;
   bool IsMipsN32Abi = TargetTriple.getEnvironment() == llvm::Triple::GNUABIN32;
 
case llvm::Triple::x86_64:
     return "x86_64-linux-gnu";
   case llvm::Triple::aarch64:
     if (IsAndroid)
       return "aarch64-linux-android";
     return "aarch64-linux-gnu";
   case llvm::Triple::aarch64_be:
     return "aarch64_be-linux-gnu";
 
+  case llvm::Triple::loongarch64: {
+    const char *Libc;
+    const char *FPFlavor;
+
+    if (TargetTriple.isGNUEnvironment()) {
+      Libc = "gnu";
+    } else if (TargetTriple.isMusl()) {
+      Libc = "musl";
+    } else {
+      return TargetTriple.str();
+    }
+
+    switch (TargetEnvironment) {
+    default:
+      return TargetTriple.str();
+    case llvm::Triple::GNUSF:
+      FPFlavor = "sf";
+      break;
+    case llvm::Triple::GNUF32:
+      FPFlavor = "f32";
+      break;
+    case llvm::Triple::GNU:
+    case llvm::Triple::GNUF64:
+      FPFlavor = "f64";
+      break;
+    }
+
+    return std::string("loongarch64-linux-") + Libc + FPFlavor;
+  }
+
   case llvm::Triple::m68k:
     return "m68k-linux-gnu";
 
   case llvm::Triple::mips:
     return IsMipsR6 ? "mipsisa32r6-linux-gnu" : "mips-linux-gnu";
   case llvm::Triple::mipsel:
     if (IsAndroid)
       return "mipsel-linux-android";

clang/test/Driver/loongarch-abi.c

 // RUN:   | FileCheck --check-prefix=LP64D %s
 // RUN: %clang --target=loongarch64-unknown-elf %s -fsyntax-only -### -mabi=lp64s 2>&1 \
 // RUN:   | FileCheck --check-prefix=LP64S %s
 // RUN: %clang --target=loongarch64-unknown-elf %s -fsyntax-only -### -mabi=lp64f 2>&1 \
 // RUN:   | FileCheck --check-prefix=LP64F %s
 // RUN: %clang --target=loongarch64-unknown-elf %s -fsyntax-only -### -mabi=lp64d 2>&1 \
 // RUN:   | FileCheck --check-prefix=LP64D %s
 
+// RUN: %clang --target=loongarch32-linux-gnusf %s -fsyntax-only -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=ILP32S %s
+// RUN: %clang --target=loongarch32-linux-gnuf32 %s -fsyntax-only -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=ILP32F %s
+// RUN: %clang --target=loongarch32-linux-gnuf64 %s -fsyntax-only -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=ILP32D %s
+
+// RUN: %clang --target=loongarch64-linux-gnusf %s -fsyntax-only -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=LP64S %s
+// RUN: %clang --target=loongarch64-linux-gnuf32 %s -fsyntax-only -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=LP64F %s
+// RUN: %clang --target=loongarch64-linux-gnuf64 %s -fsyntax-only -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=LP64D %s
+
+// Check that -mabi prevails in case of conflicts with the triple-implied ABI.
+// RUN: %clang --target=loongarch32-linux-gnuf64 %s -fsyntax-only -### -mabi=ilp32s 2>&1 \
+// RUN:   | FileCheck --check-prefix=ILP32S %s
+// RUN: %clang --target=loongarch64-linux-gnuf64 %s -fsyntax-only -### -mabi=lp64s 2>&1 \
+// RUN:   | FileCheck --check-prefix=LP64S %s
+
 // ILP32S: "-target-abi" "ilp32s"
 // ILP32F: "-target-abi" "ilp32f"
 // ILP32D: "-target-abi" "ilp32d"
 
 // LP64S: "-target-abi" "lp64s"
 // LP64F: "-target-abi" "lp64f"
 // LP64D: "-target-abi" "lp64d"