[Driver] Make -static-libgcc imply static libunwind

[jkz]

Summary

In the GNU toolchain, -static-libgcc implies that the unwindlib will be linked statically. However, when --unwindlib=libunwind, this flag is ignored, and a bare -lunwind is added to the linker args. Unfortunately, this means that if both libunwind.so, and libunwind.a are present in the library path, libunwind.so will be chosen in all cases where -static is not set.

This change makes -static-libgcc affect the -l flag produced by --unwindlib=libunwind. After this patch, providing -static-libgcc --unwindlib=libunwind will cause the driver to explicitly emit -l:libunwind.a to statically link libunwind. For all other cases it will emit -l:libunwind.so matching current behavior with a more explicit link line.

[joerg]

This is normally done by using -Bstatic/-Bdynamic around the library. See tools::addOpenMPRuntime.

[saugustine]

In D70416#1750978, @joerg wrote:

This is normally done by using -Bstatic/-Bdynamic around the library. See tools::addOpenMPRuntime.

Historically, the unwind library is a little different. Gcc uses -llibgcc_eh for static links (which is only resolved by libgcc_eh.a) and libgcc_s.so for dynamic links (which is only resolved by libgcc_s.so, which in turn pulls in libgcc.a for certain things).

[sivachandra]

Please wait for saugustine's acceptance.

[jkz]

In D70416#1750978, @joerg wrote:

This is normally done by using -Bstatic/-Bdynamic around the library. See tools::addOpenMPRuntime.

-Bstatic/-Bdynamic wrapping does seem to be more common, but that will change the linkage for libraries that are added after the run-time libraries (e.g., -lpthread). We would need something like --push-state -Bstatic -lunwind --pop-state to preserve the "mode" of the link. (IMO, the existing usages of -Bstatic, -Bdynamic wrapping are wrong). The current approach is simpler.

Additionally, I think saugustine's reasoning makes sense here, and we should match the libgcc behavior of requiring a .a or .so depending on the "mode". I'd prefer to keep this patch the way it is.

[MaskRay]

Closed by 6551ac7489fe070a2edcfac88f68c93321cba9a9

The commit does not have Differential Revision: ... so the differential is not closed automatically.

[itollefsen]

This fails to account for whether you actually have the shared and/or static version of the library.

clang/lib/Driver/ToolChains/CommonArgs.cpp

1215

If you are building with -DLIBUNWIND_ENABLE_SHARED:OFF -DLIBUNWIND_ENABLE_STATIC:ON, there's no shared version available. And vice versa. This doesn't account for that.

[saugustine]

clang/lib/Driver/ToolChains/CommonArgs.cpp

1215

Although true, I don't believe this is any different from the parallel libgcc situation. libgcc_eh is the static version, and will never be satisfied by the dynamic version. libgcc_s is the dynamic version, and can never satisfy the static version. See lines 1204-1208 above.

The case where you ask for a static compiler-rt but still want a dynamic unwind library is new. I'm not opposed to supporting it, but "what gcc does" isn't a terrible standard.

[itollefsen]

I only build libunwind as a static library because it's (so far) the approach that gets me the furthest in avoiding all of the trouble that comes from having multiple libunwind (on Linux). I'm also running with the patch from D26244 (now abandoned unfortunately).

This approach works quite well. It doesn't solve everything tough.

I can use the (default) static version of the sanitizer runtimes as long as the project being built doesn't itself use another libuwnind. If it does, I can use the shared sanitizer runtimes since they are linked against the static LLVM libunwind and therefore self-contained. Obviously, this only works for sanitiziers that have shared runtimes. Those that don't can't be used in this case. Well, as far as I've been able to work out at least.

I planned on experimenting with merging libunwind into the shared version of libc++abi (i.e. the whole libunwind archive) to see if that could solve it, but haven't gotten around to testing it yet.

clang/lib/Driver/ToolChains/CommonArgs.cpp

1215

I haven't really requested anything specific one way or the other (I think).

I'm guessing getLibGccType() returns LibGccType::SharedLibGcc because CCCIsCXX() returns true.

Even if it returned LibGccType::UnspecifiedLibGcc, the shared version would still be used though.

clang/lib/Driver/ToolChains/CommonArgs.cpp

static void AddUnwindLibrary(const ToolChain &TC, const Driver &D,
   case ToolChain::UNW_Libgcc: {
     if (LGT == LibGccType::StaticLibGcc)
       CmdArgs.push_back("-lgcc_eh");
     else
       CmdArgs.push_back("-lgcc_s");
     break;
   }
   case ToolChain::UNW_CompilerRT:
-    CmdArgs.push_back("-lunwind");
+    if (LGT == LibGccType::StaticLibGcc)
+      CmdArgs.push_back("-l:libunwind.a");
+    else
+      CmdArgs.push_back("-l:libunwind.so");
     break;
   }
 
   if (AsNeeded)
     CmdArgs.push_back("--no-as-needed");
 }
 
 static void AddLibgcc(const ToolChain &TC, const Driver &D,

clang/test/Driver/compiler-rt-unwind.c

 // General tests that the driver handles combinations of --rtlib=XXX and
 // --unwindlib=XXX properly.
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=libgcc \
 // RUN:     --gcc-toolchain="" \
 // RUN:   | FileCheck --check-prefix=RTLIB-GCC %s
 // RTLIB-GCC: "{{.*}}lgcc"
 // RTLIB-GCC: "{{.*}}lgcc_s"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=libgcc --unwindlib=libunwind \
 // RUN:     --gcc-toolchain="" \
 // RUN:   | FileCheck --check-prefix=RTLIB-GCC-UNWINDLIB-COMPILER-RT %s
 // RTLIB-GCC-UNWINDLIB-COMPILER-RT: "{{.*}}lgcc"
-// RTLIB-GCC-UNWINDLIB-COMPILER-RT: "{{.*}}lunwind"
+// RTLIB-GCC-UNWINDLIB-COMPILER-RT: "{{.*}}l:libunwind.so"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     --target=x86_64-unknown-linux -rtlib=libgcc --unwindlib=libunwind \
+// RUN:     -static-libgcc \
+// RUN:     --gcc-toolchain="" \
+// RUN:   | FileCheck --check-prefix=RTLIB-GCC-STATIC-UNWINDLIB-COMPILER-RT %s
+// RTLIB-GCC-STATIC-UNWINDLIB-COMPILER-RT: "{{.*}}lgcc"
+// RTLIB-GCC-STATIC-UNWINDLIB-COMPILER-RT: "{{.*}}l:libunwind.a"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1   \
 // RUN:     --target=x86_64-unknown-linux -rtlib=compiler-rt \
 // RUN:     --gcc-toolchain="" \
 // RUN:   | FileCheck --check-prefix=RTLIB-COMPILER-RT %s
 // RTLIB-COMPILER-RT: "{{.*}}libclang_rt.builtins-x86_64.a"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1   \