[clang] Fix clang multiarch isssue with musl

[listout]

Summary

From clang 13.0.0 has a new option -print-multiarch, matching gcc. On
linux-musl systems this outputs x86_64-linux-gnu (or aarch64-linux-gnu, etc)
instead of x86_64-linux-musl (or aarch64-linux-musl, etc).

Amongst other things, this bug breaks compiling python with clang on musl
hosts, as the python configure script does a sanity check and notices the
output of -print-multiarch is inconsistent with the linux-musl platform triplet
it (correctly) deduces for the host by other means. (The configure script
errors out with "internal configure error for the platform triplet, please file
a bug report" FWIW. This worked okay in clang 12.0.1 because python only checks
the multiarch target for consistency if $CC -print-multiarch isn't an error.)

The implementation in Linux::getMultiarchTriple() of
clang/lib/Driver/ToolChains/Linux.cpp special-cases -linux-android targets, and
assumes -linux-gnu for anything else.

Credit for this patch goes to arachsys <Chris Webb> and mgorny <Michał Górny>
Please also reffer:
https://bugs.llvm.org/show_bug.cgi?id=52127 and
llvm/llvm-project#51469

[listout]

The patch needs some rework for 15.x and above version. If people think it's appropriate then I'll be glad to make the changes

[listout]

Less drastic changes and rebased with main

[listout]

Fix missing '+'

[barannikov88]

The diff seems to be restricted to few lines. It should include the full context.

clang/lib/Driver/ToolChains/Linux.cpp

49

• !isMusl() does not mean it is "gnu".
• Why don't just use Triple::getEnvironmentTypeName?

[listout]

Using getEnvironmentTypeName() instead of isMusl()

[listout]

@barannikov88 made some changes. What do you think?

clang/lib/Driver/ToolChains/Linux.cpp

49

Sure, I'll change the patch

[listout]

Hey everyone, it would be very helpful if someone looked at this and help me merge this patch, python3.11 is failing without these modifications

[aaron.ballman]

Adding another reviewer to try to get this unstuck.

Can you add test coverage for the changes (to clang\test\Driver)? Also, there should be a release note so users know about the fix (that can go into clang\docs\ReleaseNotes.rst).

[MaskRay]

This may not be the right direction. If GCC is not configured with --enable-multi-arch, --print-multiarch output is an empty line.
The x86_64-linux-gnu style output is for Debian and its derivatives which omit vendor in the target triple.
Clang just prints this unconditionally, but the string is not really expected for non-Debian distributions.

If a build system needs to detect this (it really shouldn't), it probably should hard code Debian hierarchy, instead of expecting Clang to do something.

AIUI many musl based Linux distributions don't configure GCC with --enable-multi-arch.

[MaskRay]

This can be abandoned as --print-multiarch was removed. See also https://github.com/llvm/llvm-project/issues/51469#issuecomment-1236163566

clang/lib/Driver/ToolChains/Linux.cpp

 /// 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();
+  // Fall back to "-gnu" on unknown environment to preserve the historical
+  // behavior.
+  std::string EnvName =
+      TargetTriple
+          .getEnvironmentTypeName(TargetEnvironment !=
+                                          llvm::Triple::UnknownEnvironment
+                                      ? TargetEnvironment
+                                      : llvm::Triple::GNU)
+          .str();
   bool IsAndroid = TargetTriple.isAndroid();
   bool IsMipsR6 = TargetTriple.getSubArch() == llvm::Triple::MipsSubArch_r6;
   bool IsMipsN32Abi = TargetTriple.getEnvironment() == llvm::Triple::GNUABIN32;
 
   // For most architectures, just use whatever we have rather than trying to be
   // clever.
   switch (TargetTriple.getArch()) {
   default:
     break;
 
   // We use the existence of '/lib/<triple>' as a directory to detect some
   // common linux triples that don't quite match the Clang triple for both
   // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
   // regardless of what the actual target triple is.
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
     if (IsAndroid)
       return "arm-linux-androideabi";
-    if (TargetEnvironment == llvm::Triple::GNUEABIHF)
-      return "arm-linux-gnueabihf";
-    return "arm-linux-gnueabi";
+    return "arm-linux-" + EnvName;
   case llvm::Triple::armeb:
   case llvm::Triple::thumbeb:
-    if (TargetEnvironment == llvm::Triple::GNUEABIHF)
-      return "armeb-linux-gnueabihf";
-    return "armeb-linux-gnueabi";
+    return "armeb-linux-" + EnvName;
   case llvm::Triple::x86:
     if (IsAndroid)
       return "i686-linux-android";
-    return "i386-linux-gnu";
+    return "i386-linux-" + EnvName;
   case llvm::Triple::x86_64:
-    if (IsAndroid)
-      return "x86_64-linux-android";
-    if (TargetEnvironment == llvm::Triple::GNUX32)
-      return "x86_64-linux-gnux32";
-    return "x86_64-linux-gnu";
+    return "x86_64-linux-" + EnvName;
   case llvm::Triple::aarch64:
-    if (IsAndroid)
-      return "aarch64-linux-android";
-    return "aarch64-linux-gnu";
+    return "aarch64-linux-" + EnvName;
   case llvm::Triple::aarch64_be:
-    return "aarch64_be-linux-gnu";
+    return "aarch64_be-linux-" + EnvName;
 
   case llvm::Triple::m68k:
-    return "m68k-linux-gnu";
+    return "m68k-linux-" + EnvName;
 
   case llvm::Triple::mips:
-    return IsMipsR6 ? "mipsisa32r6-linux-gnu" : "mips-linux-gnu";
+    return (IsMipsR6 ? "mipsisa32r6-linux-" : "mips-linux-") + EnvName;
   case llvm::Triple::mipsel:
     if (IsAndroid)
       return "mipsel-linux-android";
-    return IsMipsR6 ? "mipsisa32r6el-linux-gnu" : "mipsel-linux-gnu";
+    return (IsMipsR6 ? "mipsisa32r6el-linux-" : "mipsel-linux-") + EnvName;
   case llvm::Triple::mips64: {
     std::string MT = std::string(IsMipsR6 ? "mipsisa64r6" : "mips64") +
                      "-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");
     if (D.getVFS().exists(concat(SysRoot, "/lib", MT)))
       return MT;
     if (D.getVFS().exists(concat(SysRoot, "/lib/mips64-linux-gnu")))
       return "mips64-linux-gnu";
     break;
   }
   case llvm::Triple::mips64el: {
     if (IsAndroid)
       return "mips64el-linux-android";
     std::string MT = std::string(IsMipsR6 ? "mipsisa64r6el" : "mips64el") +
                      "-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");
     if (D.getVFS().exists(concat(SysRoot, "/lib", MT)))
       return MT;
     if (D.getVFS().exists(concat(SysRoot, "/lib/mips64el-linux-gnu")))
       return "mips64el-linux-gnu";
     break;
   }
   case llvm::Triple::ppc:
     if (D.getVFS().exists(concat(SysRoot, "/lib/powerpc-linux-gnuspe")))
       return "powerpc-linux-gnuspe";
-    return "powerpc-linux-gnu";
+    return "powerpc-linux-" + EnvName;
   case llvm::Triple::ppcle:
-    return "powerpcle-linux-gnu";
+    return "powerpcle-linux-" + EnvName;
   case llvm::Triple::ppc64:
-    return "powerpc64-linux-gnu";
+    return "powerpc64-linux-" + EnvName;
   case llvm::Triple::ppc64le:
-    return "powerpc64le-linux-gnu";
+    return "powerpc64le-linux-" + EnvName;
   case llvm::Triple::riscv64:
-    return "riscv64-linux-gnu";
+    return "riscv64-linux-" + EnvName;
   case llvm::Triple::sparc:
-    return "sparc-linux-gnu";
+    return "sparc-linux-" + EnvName;
   case llvm::Triple::sparcv9:
-    return "sparc64-linux-gnu";
+    return "sparc64-linux-" + EnvName;
   case llvm::Triple::systemz:
-    return "s390x-linux-gnu";
+    return "s390x-linux-" + EnvName;
   }
   return TargetTriple.str();
 }
 
 static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
   if (Triple.isMIPS()) {
     if (Triple.isAndroid()) {
       StringRef CPUName;