support link modifier as-needed for raw-dylib-elf

usamoi · usamoi · commit f672671be86a · 2025-08-30T18:11:38.000+08:00
diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
@@ -197,7 +197,7 @@ attr_parsing_suffixed_literal_in_attribute = suffixed literals are not allowed i
     .help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
 
 attr_parsing_as_needed_compatibility =
-    linking modifier `as-needed` is only compatible with `dylib` and `framework` linking kinds
+    linking modifier `as-needed` is only compatible with `dylib`, `framework` and `raw-dylib` linking kinds
 
 attr_parsing_bundle_needs_static =
     linking modifier `bundle` is only compatible with `static` linking kind
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -168,7 +168,8 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
                     }
 
                     (sym::as_dash_needed, Some(NativeLibKind::Dylib { as_needed }))
-                    | (sym::as_dash_needed, Some(NativeLibKind::Framework { as_needed })) => {
+                    | (sym::as_dash_needed, Some(NativeLibKind::Framework { as_needed }))
+                    | (sym::as_dash_needed, Some(NativeLibKind::RawDylib { as_needed })) => {
                         report_unstable_modifier!(native_link_modifiers_as_needed);
                         assign_modifier(as_needed)
                     }
@@ -207,12 +208,12 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
 
         // Do this outside of the loop so that `import_name_type` can be specified before `kind`.
         if let Some((_, span)) = import_name_type {
-            if kind != Some(NativeLibKind::RawDylib) {
+            if !matches!(kind, Some(NativeLibKind::RawDylib { .. })) {
                 cx.emit_err(ImportNameTypeRaw { span });
             }
         }
 
-        if let Some(NativeLibKind::RawDylib) = kind
+        if let Some(NativeLibKind::RawDylib { .. }) = kind
             && name.as_str().contains('\0')
         {
             cx.emit_err(RawDylibNoNul { span: name_span });
@@ -304,7 +305,7 @@ impl LinkParser {
                     cx.emit_err(RawDylibOnlyWindows { span: nv.value_span });
                 }
 
-                NativeLibKind::RawDylib
+                NativeLibKind::RawDylib { as_needed: None }
             }
             sym::link_dash_arg => {
                 if !features.link_arg_attribute() {
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1485,7 +1485,7 @@ fn print_native_static_libs(
                 NativeLibKind::Static { bundle: None | Some(true), .. }
                 | NativeLibKind::LinkArg
                 | NativeLibKind::WasmImportModule
-                | NativeLibKind::RawDylib => None,
+                | NativeLibKind::RawDylib { .. } => None,
             }
         })
         // deduplication of consecutive repeated libraries, see rust-lang/rust#113209
@@ -2349,13 +2349,13 @@ fn linker_with_args(
             cmd.add_object(&output_path);
         }
     } else {
-        for link_path in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
+        for (link_path, as_needed) in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
             sess,
             codegen_results.crate_info.used_libraries.iter(),
             &raw_dylib_dir,
         ) {
             // Always use verbatim linkage, see comments in create_raw_dylib_elf_stub_shared_objects.
-            cmd.link_dylib_by_name(&link_path, true, false);
+            cmd.link_dylib_by_name(&link_path, true, as_needed);
         }
     }
     // As with add_upstream_native_libraries, we need to add the upstream raw-dylib symbols in case
@@ -2396,13 +2396,13 @@ fn linker_with_args(
             cmd.add_object(&output_path);
         }
     } else {
-        for link_path in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
+        for (link_path, as_needed) in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
             sess,
             native_libraries_from_nonstatics,
             &raw_dylib_dir,
         ) {
             // Always use verbatim linkage, see comments in create_raw_dylib_elf_stub_shared_objects.
-            cmd.link_dylib_by_name(&link_path, true, false);
+            cmd.link_dylib_by_name(&link_path, true, as_needed);
         }
     }
 
@@ -2711,7 +2711,7 @@ fn add_native_libs_from_crate(
                     cmd.link_framework_by_name(name, verbatim, as_needed.unwrap_or(true))
                 }
             }
-            NativeLibKind::RawDylib => {
+            NativeLibKind::RawDylib { as_needed: _ } => {
                 // Handled separately in `linker_with_args`.
             }
             NativeLibKind::WasmImportModule => {}
diff --git a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
@@ -31,7 +31,7 @@ fn collate_raw_dylibs_windows<'a>(
     let mut dylib_table = FxIndexMap::<String, FxIndexMap<Symbol, &DllImport>>::default();
 
     for lib in used_libraries {
-        if lib.kind == NativeLibKind::RawDylib {
+        if let NativeLibKind::RawDylib { .. } = lib.kind {
             let ext = if lib.verbatim { "" } else { ".dll" };
             let name = format!("{}{}", lib.name, ext);
             let imports = dylib_table.entry(name.clone()).or_default();
@@ -128,12 +128,12 @@ pub(super) fn create_raw_dylib_dll_import_libs<'a>(
 fn collate_raw_dylibs_elf<'a>(
     sess: &Session,
     used_libraries: impl IntoIterator<Item = &'a NativeLib>,
-) -> Vec<(String, Vec<DllImport>)> {
+) -> Vec<(String, Vec<DllImport>, bool)> {
     // Use index maps to preserve original order of imports and libraries.
-    let mut dylib_table = FxIndexMap::<String, FxIndexMap<Symbol, &DllImport>>::default();
+    let mut dylib_table = FxIndexMap::<String, (FxIndexMap<Symbol, &DllImport>, bool)>::default();
 
     for lib in used_libraries {
-        if lib.kind == NativeLibKind::RawDylib {
+        if let NativeLibKind::RawDylib { as_needed } = lib.kind {
             let filename = if lib.verbatim {
                 lib.name.as_str().to_owned()
             } else {
@@ -142,17 +142,19 @@ fn collate_raw_dylibs_elf<'a>(
                 format!("{prefix}{}{ext}", lib.name)
             };
 
-            let imports = dylib_table.entry(filename.clone()).or_default();
+            let (stub_imports, stub_as_needed) =
+                dylib_table.entry(filename.clone()).or_insert((Default::default(), true));
             for import in &lib.dll_imports {
-                imports.insert(import.name, import);
+                stub_imports.insert(import.name, import);
             }
+            *stub_as_needed = *stub_as_needed && as_needed.unwrap_or(true);
         }
     }
     sess.dcx().abort_if_errors();
     dylib_table
         .into_iter()
-        .map(|(name, imports)| {
-            (name, imports.into_iter().map(|(_, import)| import.clone()).collect())
+        .map(|(name, (imports, as_needed))| {
+            (name, imports.into_iter().map(|(_, import)| import.clone()).collect(), as_needed)
         })
         .collect()
 }
@@ -161,10 +163,10 @@ pub(super) fn create_raw_dylib_elf_stub_shared_objects<'a>(
     sess: &Session,
     used_libraries: impl IntoIterator<Item = &'a NativeLib>,
     raw_dylib_so_dir: &Path,
-) -> Vec<String> {
+) -> Vec<(String, bool)> {
     collate_raw_dylibs_elf(sess, used_libraries)
         .into_iter()
-        .map(|(load_filename, raw_dylib_imports)| {
+        .map(|(load_filename, raw_dylib_imports, as_needed)| {
             use std::hash::Hash;
 
             // `load_filename` is the *target/loader* filename that will end up in NEEDED.
@@ -205,7 +207,7 @@ pub(super) fn create_raw_dylib_elf_stub_shared_objects<'a>(
                 });
             };
 
-            temporary_lib_name
+            (temporary_lib_name, as_needed)
         })
         .collect()
 }
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -307,7 +307,10 @@ pub enum NativeLibKind {
     },
     /// Dynamic library (e.g. `foo.dll` on Windows) without a corresponding import library.
     /// On Linux, it refers to a generated shared library stub.
-    RawDylib,
+    RawDylib {
+        /// Whether the dynamic library will be linked only if it satisfies some undefined symbols
+        as_needed: Option<bool>,
+    },
     /// A macOS-specific kind of dynamic libraries.
     Framework {
         /// Whether the framework will be linked only if it satisfies some undefined symbols
@@ -330,11 +333,10 @@ impl NativeLibKind {
             NativeLibKind::Static { bundle, whole_archive } => {
                 bundle.is_some() || whole_archive.is_some()
             }
-            NativeLibKind::Dylib { as_needed } | NativeLibKind::Framework { as_needed } => {
-                as_needed.is_some()
-            }
-            NativeLibKind::RawDylib
-            | NativeLibKind::Unspecified
+            NativeLibKind::Dylib { as_needed }
+            | NativeLibKind::Framework { as_needed }
+            | NativeLibKind::RawDylib { as_needed } => as_needed.is_some(),
+            NativeLibKind::Unspecified
             | NativeLibKind::LinkArg
             | NativeLibKind::WasmImportModule => false,
         }
@@ -347,7 +349,9 @@ impl NativeLibKind {
     pub fn is_dllimport(&self) -> bool {
         matches!(
             self,
-            NativeLibKind::Dylib { .. } | NativeLibKind::RawDylib | NativeLibKind::Unspecified
+            NativeLibKind::Dylib { .. }
+                | NativeLibKind::RawDylib { .. }
+                | NativeLibKind::Unspecified
         )
     }
 }
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
@@ -218,7 +218,7 @@ impl<'tcx> Collector<'tcx> {
                 .flatten()
         {
             let dll_imports = match attr.kind {
-                NativeLibKind::RawDylib => foreign_items
+                NativeLibKind::RawDylib { .. } => foreign_items
                     .iter()
                     .map(|&child_item| {
                         self.build_dll_import(
diff --git a/compiler/rustc_session/src/config/native_libs.rs b/compiler/rustc_session/src/config/native_libs.rs
@@ -135,7 +135,8 @@ fn parse_and_apply_modifier(cx: &ParseNativeLibCx<'_>, modifier: &str, native_li
         ),
 
         ("as-needed", NativeLibKind::Dylib { as_needed })
-        | ("as-needed", NativeLibKind::Framework { as_needed }) => {
+        | ("as-needed", NativeLibKind::Framework { as_needed })
+        | ("as-needed", NativeLibKind::RawDylib { as_needed }) => {
             cx.on_unstable_value(
                 "linking modifier `as-needed` is unstable",
                 ", the `-Z unstable-options` flag must also be passed to use it",
diff --git a/tests/ui/linkage-attr/raw-dylib/elf/as_needed.rs b/tests/ui/linkage-attr/raw-dylib/elf/as_needed.rs
@@ -0,0 +1,43 @@
+//@ only-elf
+//@ needs-dynamic-linking
+
+//@ only-gnu
+//@ only-x86_64
+//@ revisions: as_needed no_as_needed no_modifier merge_1 merge_2 merge_3 merge_4
+
+//@ [as_needed] run-pass
+//@ [no_as_needed] run-fail
+//@ [no_modifier] run-pass
+//@ [merge_1] run-fail
+//@ [merge_2] run-fail
+//@ [merge_3] run-fail
+//@ [merge_4] run-pass
+
+#![allow(incomplete_features)]
+#![feature(raw_dylib_elf)]
+#![feature(native_link_modifiers_as_needed)]
+
+#[cfg_attr(
+    as_needed,
+    link(name = "taiqannf1y28z2rw", kind = "raw-dylib", modifiers = "+as-needed")
+)]
+#[cfg_attr(
+    no_as_needed,
+    link(name = "taiqannf1y28z2rw", kind = "raw-dylib", modifiers = "-as-needed")
+)]
+#[cfg_attr(no_modifier, link(name = "taiqannf1y28z2rw", kind = "raw-dylib"))]
+unsafe extern "C" {}
+
+#[cfg_attr(merge_1, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "+as-needed"))]
+#[cfg_attr(merge_2, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "-as-needed"))]
+#[cfg_attr(merge_3, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "-as-needed"))]
+#[cfg_attr(merge_4, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "+as-needed"))]
+unsafe extern "C" {}
+
+#[cfg_attr(merge_1, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "-as-needed"))]
+#[cfg_attr(merge_2, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "+as-needed"))]
+#[cfg_attr(merge_3, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "-as-needed"))]
+#[cfg_attr(merge_4, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "+as-needed"))]
+unsafe extern "C" {}
+
+fn main() {}

Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,8 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`(sym::as_dash_needed, Some(NativeLibKind::Dylib { as_needed }))`
`171`		`- \| (sym::as_dash_needed, Some(NativeLibKind::Framework { as_needed })) => {`
	`171`	`+ \| (sym::as_dash_needed, Some(NativeLibKind::Framework { as_needed }))`
	`172`	`+ \| (sym::as_dash_needed, Some(NativeLibKind::RawDylib { as_needed })) => {`
`172`	`173`	`report_unstable_modifier!(native_link_modifiers_as_needed);`
`173`	`174`	`assign_modifier(as_needed)`
`174`	`175`	`}`
`@@ -207,12 +208,12 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {`
`207`	`208`
`208`	`209`	// Do this outside of the loop so that `import_name_type` can be specified before `kind`.
`209`	`210`	`if let Some((_, span)) = import_name_type {`
`210`		`- if kind != Some(NativeLibKind::RawDylib) {`
	`211`	`+ if !matches!(kind, Some(NativeLibKind::RawDylib { .. })) {`
`211`	`212`	`cx.emit_err(ImportNameTypeRaw { span });`
`212`	`213`	`}`
`213`	`214`	`}`
`214`	`215`
`215`		`- if let Some(NativeLibKind::RawDylib) = kind`
	`216`	`+ if let Some(NativeLibKind::RawDylib { .. }) = kind`
`216`	`217`	`&& name.as_str().contains('\0')`
`217`	`218`	`{`
`218`	`219`	`cx.emit_err(RawDylibNoNul { span: name_span });`
`@@ -304,7 +305,7 @@ impl LinkParser {`
`304`	`305`	`cx.emit_err(RawDylibOnlyWindows { span: nv.value_span });`
`305`	`306`	`}`
`306`	`307`
`307`		`- NativeLibKind::RawDylib`
	`308`	`+ NativeLibKind::RawDylib { as_needed: None }`
`308`	`309`	`}`
`309`	`310`	`sym::link_dash_arg => {`
`310`	`311`	`if !features.link_arg_attribute() {`
Original file line number	Diff line number	Diff line change
`@@ -1485,7 +1485,7 @@ fn print_native_static_libs(`
`1485`	`1485`	`NativeLibKind::Static { bundle: None \| Some(true), .. }`
`1486`	`1486`	`\| NativeLibKind::LinkArg`
`1487`	`1487`	`\| NativeLibKind::WasmImportModule`
`1488`		`- \| NativeLibKind::RawDylib => None,`
	`1488`	`+ \| NativeLibKind::RawDylib { .. } => None,`
`1489`	`1489`	`}`
`1490`	`1490`	`})`
`1491`	`1491`	`// deduplication of consecutive repeated libraries, see rust-lang/rust#113209`
`@@ -2349,13 +2349,13 @@ fn linker_with_args(`
`2349`	`2349`	`cmd.add_object(&output_path);`
`2350`	`2350`	`}`
`2351`	`2351`	`} else {`
`2352`		`- for link_path in raw_dylib::create_raw_dylib_elf_stub_shared_objects(`
	`2352`	`+ for (link_path, as_needed) in raw_dylib::create_raw_dylib_elf_stub_shared_objects(`
`2353`	`2353`	`sess,`
`2354`	`2354`	`codegen_results.crate_info.used_libraries.iter(),`
`2355`	`2355`	`&raw_dylib_dir,`
`2356`	`2356`	`) {`
`2357`	`2357`	`// Always use verbatim linkage, see comments in create_raw_dylib_elf_stub_shared_objects.`
`2358`		`- cmd.link_dylib_by_name(&link_path, true, false);`
	`2358`	`+ cmd.link_dylib_by_name(&link_path, true, as_needed);`
`2359`	`2359`	`}`
`2360`	`2360`	`}`
`2361`	`2361`	`// As with add_upstream_native_libraries, we need to add the upstream raw-dylib symbols in case`
`@@ -2396,13 +2396,13 @@ fn linker_with_args(`
`2396`	`2396`	`cmd.add_object(&output_path);`
`2397`	`2397`	`}`
`2398`	`2398`	`} else {`
`2399`		`- for link_path in raw_dylib::create_raw_dylib_elf_stub_shared_objects(`
	`2399`	`+ for (link_path, as_needed) in raw_dylib::create_raw_dylib_elf_stub_shared_objects(`
`2400`	`2400`	`sess,`
`2401`	`2401`	`native_libraries_from_nonstatics,`
`2402`	`2402`	`&raw_dylib_dir,`
`2403`	`2403`	`) {`
`2404`	`2404`	`// Always use verbatim linkage, see comments in create_raw_dylib_elf_stub_shared_objects.`
`2405`		`- cmd.link_dylib_by_name(&link_path, true, false);`
	`2405`	`+ cmd.link_dylib_by_name(&link_path, true, as_needed);`
`2406`	`2406`	`}`
`2407`	`2407`	`}`
`2408`	`2408`
`@@ -2711,7 +2711,7 @@ fn add_native_libs_from_crate(`
`2711`	`2711`	`cmd.link_framework_by_name(name, verbatim, as_needed.unwrap_or(true))`
`2712`	`2712`	`}`
`2713`	`2713`	`}`
`2714`		`- NativeLibKind::RawDylib => {`
	`2714`	`+ NativeLibKind::RawDylib { as_needed: _ } => {`
`2715`	`2715`	// Handled separately in `linker_with_args`.
`2716`	`2716`	`}`
`2717`	`2717`	`NativeLibKind::WasmImportModule => {}`
Original file line number	Diff line number	Diff line change
`@@ -218,7 +218,7 @@ impl<'tcx> Collector<'tcx> {`
`218`	`218`	`.flatten()`
`219`	`219`	`{`
`220`	`220`	`let dll_imports = match attr.kind {`
`221`		`- NativeLibKind::RawDylib => foreign_items`
	`221`	`+ NativeLibKind::RawDylib { .. } => foreign_items`
`222`	`222`	`.iter()`
`223`	`223`	`.map(\|&child_item\| {`
`224`	`224`	`self.build_dll_import(`