Generalize -C prefer-dyanmic to carry an optional subset of the crates to prefer dynamic linkage on.

Note: carrying an empty set here is *not* the same as `-C prefer-dyanmic=no`
(and the latter is the default behavior for `rustc`). As discussed in detail in
the comments for `enum PreferDynamicSet` (and also in the comments of
`rustc_metadata::dependency_format`), `-C prefer-dynamic=no` asks the compiler
to guess what linkage to use, and it currently guesses all static first, and if
that fails, then it prefers dynamic linkage for all crates that provide both
dynamic and static libraries.

Using an empty set for `-C prefer-dynamic`, on the other hand, means the
compiler should never prefer dynamic linkage over static linkage, even if that
means it won't be able to successfully link the build product.

Author: pnkfelix

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -77,7 +77,7 @@ fn prepare_lto(
     // with either fat or thin LTO
     let mut upstream_modules = Vec::new();
     if cgcx.lto != Lto::ThinLocal {
-        if cgcx.opts.cg.prefer_dynamic {
+        if cgcx.opts.cg.prefer_dynamic.is_non_empty() {
             diag_handler
                 .struct_err("cannot prefer dynamic linking when performing LTO")
                 .note(

compiler/rustc_codegen_llvm/src/consts.rs

@@ -256,7 +256,7 @@ impl CodegenCx<'ll, 'tcx> {
             debug_assert!(
                 !(self.tcx.sess.opts.cg.linker_plugin_lto.enabled()
                     && self.tcx.sess.target.is_like_windows
-                    && self.tcx.sess.opts.cg.prefer_dynamic)
+                    && self.tcx.sess.opts.cg.prefer_dynamic.is_non_empty())
             );
 
             if needs_dll_storage_attr {

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -1950,7 +1950,7 @@ fn msvc_imps_needed(tcx: TyCtxt<'_>) -> bool {
     assert!(
         !(tcx.sess.opts.cg.linker_plugin_lto.enabled()
             && tcx.sess.target.is_like_windows
-            && tcx.sess.opts.cg.prefer_dynamic)
+            && tcx.sess.opts.cg.prefer_dynamic.is_non_empty())
     );
 
     tcx.sess.target.is_like_windows &&

compiler/rustc_metadata/src/dependency_format.rs

@@ -85,23 +85,43 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
         return Vec::new();
     }
 
+    let prefer_dynamic = &sess.opts.cg.prefer_dynamic;
+
+    // traverses all crates to see if any are in the prefer-dynamic set.
+    let prefer_dynamic_for_any_crate = || {
+        if prefer_dynamic.is_empty() {
+            // skip traversal if we know it cannot ever bear fruit.
+            false
+        } else {
+            tcx.crates(()).iter().any(|cnum| prefer_dynamic.contains_crate(tcx.crate_name(*cnum)))
+        }
+    };
+
     let preferred_linkage = match ty {
-        // Generating a dylib without `-C prefer-dynamic` means that we're going
-        // to try to eagerly statically link all dependencies. This is normally
-        // done for end-product dylibs, not intermediate products.
+        // If `-C prefer-dynamic` is not set for any crate, then means that we're
+        // going to try to eagerly statically link all dependencies into the dylib.
+        // This is normally done for end-product dylibs, not intermediate products.
         //
-        // Treat cdylibs similarly. If `-C prefer-dynamic` is set, the caller may
-        // be code-size conscious, but without it, it makes sense to statically
-        // link a cdylib.
-        CrateType::Dylib | CrateType::Cdylib if !sess.opts.cg.prefer_dynamic => Linkage::Static,
-        CrateType::Dylib | CrateType::Cdylib => Linkage::Dynamic,
+        // Treat cdylibs similarly. If `-C prefer-dynamic` is set for any given
+        // crate, the caller may be code-size conscious, but without it, it
+        // makes sense to statically link a cdylib.
+        CrateType::Dylib | CrateType::Cdylib => {
+            if prefer_dynamic_for_any_crate() {
+                Linkage::Dynamic
+            } else {
+                Linkage::Static
+            }
+        }
 
-        // If the global prefer_dynamic switch is turned off, or the final
+        // If `prefer_dynamic` is not set for any crate, or the final
         // executable will be statically linked, prefer static crate linkage.
-        CrateType::Executable if !sess.opts.cg.prefer_dynamic || sess.crt_static(Some(ty)) => {
-            Linkage::Static
+        CrateType::Executable => {
+            if !prefer_dynamic_for_any_crate() || sess.crt_static(Some(ty)) {
+                Linkage::Static
+            } else {
+                Linkage::Dynamic
+            }
         }
-        CrateType::Executable => Linkage::Dynamic,
 
         // proc-macro crates are mostly cdylibs, but we also need metadata.
         CrateType::ProcMacro => Linkage::Static,
@@ -148,6 +168,11 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
                 ));
             }
             return Vec::new();
+        } else {
+            tracing::info!(
+                "calculate_type {} attempt_static failed; falling through to dynamic linkage",
+                tcx.crate_name(LOCAL_CRATE)
+            );
         }
     }
 
@@ -163,7 +188,14 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
         }
         let name = tcx.crate_name(cnum);
         let src: Lrc<CrateSource> = tcx.used_crate_source(cnum);
-        if src.dylib.is_some() {
+        // We should prefer the dylib, when available, if either:
+        // 1. the user has requested that dylib (or all dylibs) via `-C prefer-dynamic`, or
+        // 2. for backwards compatibility: if the prefer-dynamic subset is unset, then we *still*
+        //    favor dylibs here. This way, if static linking fails above, we might still hope to
+        //    succeed at linking here.
+        let prefer_dylib =
+            |name| -> bool { prefer_dynamic.is_unset() || prefer_dynamic.contains_crate(name) };
+        if src.dylib.is_some() && prefer_dylib(name) {
             tracing::info!("calculate_type {} adding dylib: {}", tcx.crate_name(LOCAL_CRATE), name);
             add_library(tcx, cnum, RequireDynamic, &mut formats, &mut rev_deps, LOCAL_CRATE);
             let deps = tcx.dylib_dependency_formats(cnum);
@@ -196,13 +228,16 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
     // If the crate hasn't been included yet and it's not actually required
     // (e.g., it's an allocator) then we skip it here as well.
     for &cnum in tcx.crates(()).iter() {
+        let name = tcx.crate_name(cnum);
         let src: Lrc<CrateSource> = tcx.used_crate_source(cnum);
-        if src.dylib.is_none()
-            && !formats.contains_key(&cnum)
-            && tcx.dep_kind(cnum) == CrateDepKind::Explicit
-        {
+        let static_available = src.rlib.is_some() || src.rmeta.is_some();
+        let prefer_static =
+            src.dylib.is_none() || (static_available && !prefer_dynamic.contains_crate(name));
+        let missing = !formats.contains_key(&cnum);
+        let actually_required = tcx.dep_kind(cnum) == CrateDepKind::Explicit;
+        if prefer_static && missing && actually_required {
             assert!(src.rlib.is_some() || src.rmeta.is_some());
-            tracing::info!("adding staticlib: {}", tcx.crate_name(cnum));
+            tracing::info!("adding staticlib: {}", name);
             add_library(tcx, cnum, RequireStatic, &mut formats, &mut rev_deps, LOCAL_CRATE);
             ret[cnum.as_usize() - 1] = Linkage::Static;
         }

compiler/rustc_session/src/config.rs

@@ -63,6 +63,68 @@ pub enum CFGuard {
     Checks,
 }
 
+/// Handle `-C prefer-dynamic` flag: either its all, or its some explicit
+/// subset (potentially the empty set).
+#[derive(Clone, PartialEq, Hash, Debug)]
+pub enum PreferDynamicSet {
+    /// Specified by the absence of `-C prefer-dynamic`, or via an explicit `-C prefer-dynamic=...`
+    /// with value `n`, `no`, or `off`.
+    ///
+    /// Under this (default) behavior, the compiler first optimistically attempts to statically
+    /// link everything, but if that fails, then attempts to dynamically link *everything* with a
+    /// dylib path available.
+    Unset,
+
+    /// Specified via `-C prefer-dynamic` with no value. For backwards-compatibility, also
+    /// specified via `-C prefer-dynamic=...` with value `y`, `yes`, or `on`.
+    All,
+
+    /// Specified via `-C prefer-dynamic=crate,...`.
+    Set(BTreeSet<String>),
+}
+
+impl PreferDynamicSet {
+    pub fn unset() -> Self {
+        PreferDynamicSet::Unset
+    }
+
+    pub fn every_crate() -> Self {
+        PreferDynamicSet::All
+    }
+
+    pub fn subset(crates: impl Iterator<Item = impl ToString>) -> Self {
+        PreferDynamicSet::Set(crates.map(|x| x.to_string()).collect())
+    }
+
+    pub fn is_unset(&self) -> bool {
+        if let PreferDynamicSet::Unset = *self { true } else { false }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        match self {
+            PreferDynamicSet::Unset => true,
+            PreferDynamicSet::All => false,
+            PreferDynamicSet::Set(s) => s.len() == 0,
+        }
+    }
+
+    pub fn is_non_empty(&self) -> bool {
+        match self {
+            PreferDynamicSet::Unset => false,
+            PreferDynamicSet::All => true,
+            PreferDynamicSet::Set(s) => s.len() > 0,
+        }
+    }
+
+    pub fn contains_crate(&self, crate_name: Symbol) -> bool {
+        match self {
+            PreferDynamicSet::Unset => false,
+            PreferDynamicSet::All => true,
+            PreferDynamicSet::Set(s) => s.iter().any(|s| s == &*crate_name.as_str()),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Hash)]
 pub enum OptLevel {
     No,         // -O0
@@ -2420,8 +2482,8 @@ crate mod dep_tracking {
     use super::LdImpl;
     use super::{
         CFGuard, CrateType, DebugInfo, ErrorOutputType, InstrumentCoverage, LinkerPluginLto,
-        LtoCli, OptLevel, OutputType, OutputTypes, Passes, SourceFileHashAlgorithm,
-        SwitchWithOptPath, SymbolManglingVersion, TrimmedDefPaths,
+        LtoCli, OptLevel, OutputType, OutputTypes, Passes, PreferDynamicSet,
+        SourceFileHashAlgorithm, SwitchWithOptPath, SymbolManglingVersion, TrimmedDefPaths,
     };
     use crate::lint;
     use crate::options::WasiExecModel;
@@ -2510,6 +2572,7 @@ crate mod dep_tracking {
         TrimmedDefPaths,
         Option<LdImpl>,
         OutputType,
+        PreferDynamicSet,
         RealFileName,
     );
 

compiler/rustc_session/src/options.rs

@@ -376,6 +376,8 @@ mod desc {
         "one of supported relocation models (`rustc --print relocation-models`)";
     pub const parse_code_model: &str = "one of supported code models (`rustc --print code-models`)";
     pub const parse_tls_model: &str = "one of supported TLS models (`rustc --print tls-models`)";
+    pub const parse_prefer_dynamic: &str =
+        "one of `y`, `yes`, `on`, `n`, `no`, `off`, or a comma separated list of crates";
     pub const parse_target_feature: &str = parse_string;
     pub const parse_wasi_exec_model: &str = "either `command` or `reactor`";
     pub const parse_split_debuginfo: &str =
@@ -835,6 +837,38 @@ mod parse {
         true
     }
 
+    crate fn parse_prefer_dynamic(slot: &mut PreferDynamicSet, v: Option<&str>) -> bool {
+        let s = match v {
+            // Note: n/no/off do *not* map to an empty-set of crates.
+            //
+            // This is to continue supporting rustc's historical behavior where it attempts to
+            // link everything statically, but failing that, then greedily link as many crates
+            // dynamically as it can.
+            //
+            // If these options mapped to an empty set, then that would denote that no dynamic
+            // linkage should be given preference over static, which would not correspond to
+            // historical meaning of `-C prefer-dynamic=no`.
+            //
+            // (One requests an empty set by writing `-C prefer-dynamic=`, with an empty string
+            // as the value.)
+            Some("n") | Some("no") | Some("off") => PreferDynamicSet::unset(),
+
+            // `-C prefer-dynamic` gives all crates preferred dynamic linkage.
+            // `-C prefer-dynamic=...` with `y`/`yes`/`on` is a synonym, for backwards
+            // compatibility.
+            Some("y") | Some("yes") | Some("on") | None => PreferDynamicSet::every_crate(),
+
+            // `-C prefer-dynamic=crate1,crate2,...` gives *just* crate1, crate2, ... preferred
+            // dynamic linkage.
+            Some(s) => {
+                let v = s.split(',').map(|s| s.to_string()).collect();
+                PreferDynamicSet::Set(v)
+            }
+        };
+        *slot = s;
+        return true;
+    }
+
     crate fn parse_src_file_hash(
         slot: &mut Option<SourceFileHashAlgorithm>,
         v: Option<&str>,
@@ -962,7 +996,7 @@ options! {
         "panic strategy to compile crate with"),
     passes: Vec<String> = (Vec::new(), parse_list, [TRACKED],
         "a list of extra LLVM passes to run (space separated)"),
-    prefer_dynamic: bool = (false, parse_bool, [TRACKED],
+    prefer_dynamic: PreferDynamicSet = (PreferDynamicSet::unset(), parse_prefer_dynamic, [TRACKED],
         "prefer dynamic linking to static linking (default: no)"),
     profile_generate: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
         parse_switch_with_opt_path, [TRACKED],

compiler/rustc_session/src/session.rs

@@ -1379,7 +1379,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
     // when compiling for LLD ThinLTO. This way we can validly just not generate
     // the `dllimport` attributes and `__imp_` symbols in that case.
     if sess.opts.cg.linker_plugin_lto.enabled()
-        && sess.opts.cg.prefer_dynamic
+        && sess.opts.cg.prefer_dynamic.is_non_empty()
         && sess.target.is_like_windows
     {
         sess.err(

src/doc/rustc/src/codegen-options/index.md

@@ -402,6 +402,13 @@ linkage. This flag takes one of the following values:
 
 * `y`, `yes`, `on`, or no value: use dynamic linking.
 * `n`, `no`, or `off`: use static linking (the default).
+* A comma-separated list of crate names `crate1,crate2,...`: prefer dynamic
+  linking, but solely for the indicated crates. For example, to statically link
+  everything except `std`, use `-C prefer-dynamic=std`.
+
+Note that the explicit list of crate names variant of this flag is gated behind
+`-Zprefer-dynamic-subset`; as a special case, one can enable the handling of
+the single crate `std` as shown in the example above via `-Zprefer-dynamic-std`.
 
 ## profile-generate