Use static native libraries when linking static executables

On ELF targets like Linux, gcc/ld will create a dynamically-linked
executable without warning, even when passed `-static`, when asked to
link to a `.so`. Avoid this confusing and unintended behavior by always
using the static version of libraries when trying to link static
executables.

Author: smaeul

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1992,7 +1992,7 @@ fn linker_with_args<'a>(
     // external build system already has the native dependencies defined, and it
     // will provide them to the linker itself.
     if sess.opts.unstable_opts.link_native_libraries {
-        add_upstream_native_libraries(cmd, sess, codegen_results);
+        add_upstream_native_libraries(cmd, sess, codegen_results, crate_type);
     }
 
     // Link with the import library generated for any raw-dylib functions.
@@ -2593,8 +2593,7 @@ fn add_upstream_rust_crates<'a>(
     }
 }
 
-/// Link in all of our upstream crates' native dependencies. Remember that all of these upstream
-/// native dependencies are all non-static dependencies. We've got two cases then:
+/// Link in all of our upstream crates' native dependencies. We have two cases:
 ///
 /// 1. The upstream crate is an rlib. In this case we *must* link in the native dependency because
 /// the rlib is just an archive.
@@ -2612,6 +2611,7 @@ fn add_upstream_native_libraries(
     cmd: &mut dyn Linker,
     sess: &Session,
     codegen_results: &CodegenResults,
+    crate_type: CrateType,
 ) {
     let mut last = (None, NativeLibKind::Unspecified, None);
     for &cnum in &codegen_results.crate_info.used_crates {
@@ -2636,7 +2636,19 @@ fn add_upstream_native_libraries(
                 NativeLibKind::Dylib { as_needed } => {
                     cmd.link_dylib(name, verbatim, as_needed.unwrap_or(true))
                 }
-                NativeLibKind::Unspecified => cmd.link_dylib(name, verbatim, true),
+                NativeLibKind::Unspecified => {
+                    // On some targets, like Linux, linking a static executable inhibits using
+                    // dylibs at all. Force native libraries to be static, even if for example
+                    // an upstream rlib was originally linked against a native shared library.
+                    if crate_type == config::CrateType::Executable
+                        && sess.crt_static(Some(crate_type))
+                        && !sess.target.options.crt_static_allows_dylibs
+                    {
+                        cmd.link_staticlib(name, verbatim)
+                    } else {
+                        cmd.link_dylib(name, verbatim, true)
+                    }
+                },
                 NativeLibKind::Framework { as_needed } => {
                     cmd.link_framework(name, as_needed.unwrap_or(true))
                 }