implement self-contained linking with lld via linker features

Until necessary, the linker features are inferred from the linker
flavor. This is done to reduce churn on all of the targets until we're
very certain the design matches our expectations.

Author: lqd

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -22,10 +22,10 @@ use rustc_session::utils::NativeLibKind;
 use rustc_session::{filesearch, Session};
 use rustc_span::symbol::Symbol;
 use rustc_target::spec::crt_objects::CrtObjects;
-use rustc_target::spec::LinkSelfContainedComponents;
 use rustc_target::spec::LinkSelfContainedDefault;
 use rustc_target::spec::LinkerFlavorCli;
 use rustc_target::spec::{Cc, LinkOutputKind, LinkerFlavor, Lld, PanicStrategy};
+use rustc_target::spec::{LinkSelfContainedComponents, LinkerFeatures};
 use rustc_target::spec::{RelocModel, RelroLevel, SanitizerSet, SplitDebuginfo};
 
 use super::archive::{ArchiveBuilder, ArchiveBuilderBuilder};
@@ -741,6 +741,8 @@ fn link_natively(
     info!("preparing {:?} to {:?}", crate_type, out_filename);
     let (linker_path, flavor) = linker_and_flavor(sess);
     let self_contained_components = self_contained_components(sess, crate_type);
+    let linker_features = linker_features(sess, flavor);
+
     let mut cmd = linker_with_args(
         &linker_path,
         flavor,
@@ -751,6 +753,7 @@ fn link_natively(
         out_filename,
         codegen_results,
         self_contained_components,
+        linker_features,
     )?;
 
     linker::disable_localization(&mut cmd);
@@ -1816,6 +1819,40 @@ fn self_contained_components(sess: &Session, crate_type: CrateType) -> LinkSelfC
     }
 }
 
+/// Returns the set of linker features that are:
+/// - enabled on the CLI, or by the current target
+/// - and, are not disabled on the CLI
+fn linker_features(sess: &Session, flavor: LinkerFlavor) -> LinkerFeatures {
+    // Note: currently, both the linker flavors and linker features model the same functionality:
+    // they can only contain whether the linker is used via a C/C++ compiler, and whether the linker
+    // used is lld.
+    //
+    // While linker features are unstable, and in order to reduce churn on the many target specs
+    // (e.g. by adding linker features there, and removing the cc/lld components from the flavors)
+    // we currently *infer* the target's linker features from the linker flavor itself.
+    //
+    // For stabilization, and/or when linker features gain additional components that are not
+    // modeled by the current linker flavors, the refactoring mentioned above may need to be done.
+    let mut linker_features_target = LinkerFeatures::empty();
+    if flavor.uses_cc() {
+        linker_features_target.insert(LinkerFeatures::CC);
+    }
+    if flavor.uses_lld() {
+        linker_features_target.insert(LinkerFeatures::LLD);
+    }
+
+    // Now we merge the features enabled on the CLI and the target, and remove the ones disabled on
+    // the CLI.
+    let linker_features_cli = &sess.opts.unstable_opts.linker_features;
+    debug!(
+        "linker features - target: {:?}, enabled on CLI: {:?}, disabled on CLI: {:?}",
+        linker_features_target, linker_features_cli.enabled, linker_features_cli.disabled
+    );
+    let linker_features =
+        (linker_features_cli.enabled | linker_features_target) - linker_features_cli.disabled;
+    linker_features
+}
+
 /// Add pre-link object files defined by the target spec.
 fn add_pre_link_objects(
     cmd: &mut dyn Linker,
@@ -2114,6 +2151,7 @@ fn linker_with_args(
     out_filename: &Path,
     codegen_results: &CodegenResults,
     self_contained_components: LinkSelfContainedComponents,
+    linker_features: LinkerFeatures,
 ) -> Result<Command, ErrorGuaranteed> {
     let self_contained_crt_objects = self_contained_components.is_crt_objects_enabled();
     let cmd = &mut *super::linker::get_linker(
@@ -2301,6 +2339,7 @@ fn linker_with_args(
         codegen_results,
         out_filename,
         tmpdir,
+        linker_features,
     );
 
     // Can be used for arbitrary order-independent options.
@@ -2334,9 +2373,10 @@ fn add_order_independent_options(
     codegen_results: &CodegenResults,
     out_filename: &Path,
     tmpdir: &Path,
+    linker_features: LinkerFeatures,
 ) {
     // Take care of the flavors and CLI options requesting the `lld` linker.
-    add_lld_args(cmd, sess, flavor, self_contained_components);
+    add_lld_args(cmd, sess, flavor, self_contained_components, linker_features);
 
     add_apple_sdk(cmd, sess, flavor);
 
@@ -3053,24 +3093,21 @@ fn get_apple_sdk_root(sdk_name: &str) -> Result<String, errors::AppleSdkRootErro
     }
 }
 
-/// When using the linker flavors opting in to `lld`, add the necessary paths and arguments to
-/// invoke it:
+/// When using the linker flavors (or linker feature) opting in to `lld`, add the necessary paths
+/// and arguments to invoke it:
 /// - when the self-contained linker flag is active: the build of `lld` distributed with rustc,
 /// - or any `lld` available to `cc`.
+#[instrument(level = "debug", skip(cmd, sess))]
 fn add_lld_args(
     cmd: &mut dyn Linker,
     sess: &Session,
     flavor: LinkerFlavor,
     self_contained_components: LinkSelfContainedComponents,
+    linker_features: LinkerFeatures,
 ) {
-    debug!(
-        "add_lld_args requested, flavor: '{:?}', target self-contained components: {:?}",
-        flavor, self_contained_components,
-    );
-
-    // If the flavor doesn't use a C/C++ compiler to invoke the linker, or doesn't opt in to `lld`,
-    // we don't need to do anything.
-    if !(flavor.uses_cc() && flavor.uses_lld()) {
+    // If we're not using a C/C++ compiler to invoke the linker, or don't opt in to `lld`, we don't
+    // need to do anything.
+    if !(linker_features.is_cc_enabled() && linker_features.is_lld_enabled()) {
         return;
     }