Move NativeLib::filename to the rmeta-link archive member

Author: mehdiakiki

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -311,7 +311,12 @@ fn link_rlib<'a>(
         .collect();
 
     let metadata_link_file = if matches!(flavor, RlibFlavor::Normal) {
-        let metadata_link = rmeta_link::RmetaLink { rust_object_files };
+        let native_lib_filenames: Vec<(String, String)> = crate_info
+            .used_libraries
+            .iter()
+            .filter_map(|lib| Some((lib.name.to_string(), lib.filename?.to_string())))
+            .collect();
+        let metadata_link = rmeta_link::RmetaLink { rust_object_files, native_lib_filenames };
         let metadata_link_data = metadata_link.encode();
         let (wrapper, _) =
             create_wrapper_file(sess, rmeta_link::SECTION.to_string(), &metadata_link_data);

compiler/rustc_codegen_ssa/src/back/metadata.rs

@@ -103,6 +103,41 @@ impl MetadataLoader for DefaultMetadataLoader {
             load_metadata_with(path, |data| search_for_section(path, data, ".rustc"))
         }
     }
+
+    fn get_rlib_native_lib_filenames(&self, target: &Target, path: &Path) -> Vec<(String, String)> {
+        debug!("getting rmeta-link native lib filenames for {}", path.display());
+        let Ok(file) = File::open(path) else {
+            debug!("failed to open rlib for native-lib filenames: {}", path.display());
+            return Vec::new();
+        };
+        let Ok(mmap) = (unsafe { Mmap::map(file) }) else {
+            debug!("failed to mmap rlib for native-lib filenames: {}", path.display());
+            return Vec::new();
+        };
+
+        if target.is_like_aix {
+            let Ok(archive) = object::read::archive::ArchiveFile::parse(&*mmap) else {
+                return Vec::new();
+            };
+            for entry in archive.members() {
+                let Ok(entry) = entry else { continue };
+                if entry.name() == super::rmeta_link::FILENAME.as_bytes() {
+                    let Ok(member_data) = entry.data(&*mmap) else { continue };
+                    let Ok(section_data) = get_metadata_xcoff(path, member_data) else {
+                        continue;
+                    };
+                    return super::rmeta_link::RmetaLink::decode(section_data)
+                        .map(|rl| rl.native_lib_filenames)
+                        .unwrap_or_default();
+                }
+            }
+            return Vec::new();
+        }
+
+        super::rmeta_link::read_from_data(&mmap, path)
+            .map(|rl| rl.native_lib_filenames)
+            .unwrap_or_default()
+    }
 }
 
 pub(super) fn search_for_section<'a>(

compiler/rustc_codegen_ssa/src/back/rmeta_link.rs

@@ -16,21 +16,29 @@ pub(crate) const SECTION: &str = ".rmeta-link";
 
 pub struct RmetaLink {
     pub rust_object_files: Vec<String>,
+    /// `(NativeLib::name, filename)` pairs.
+    pub native_lib_filenames: Vec<(String, String)>,
 }
 
 impl RmetaLink {
     pub(crate) fn encode(&self) -> Vec<u8> {
         let mut encoder = MemEncoder::new();
         self.rust_object_files.encode(&mut encoder);
+        self.native_lib_filenames.encode(&mut encoder);
         let mut data = encoder.finish();
         data.extend_from_slice(MAGIC_END_BYTES);
         data
     }
 
     pub(crate) fn decode(data: &[u8]) -> Option<RmetaLink> {
-        let mut decoder = MemDecoder::new(data, 0).ok()?;
-        let rust_object_files = Vec::<String>::decode(&mut decoder);
-        Some(RmetaLink { rust_object_files })
+        std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            let mut decoder = MemDecoder::new(data, 0).ok()?;
+            let rust_object_files = Vec::<String>::decode(&mut decoder);
+            let native_lib_filenames = Vec::<(String, String)>::decode(&mut decoder);
+            Some(RmetaLink { rust_object_files, native_lib_filenames })
+        }))
+        .ok()
+        .flatten()
     }
 }
 

compiler/rustc_metadata/src/creader.rs

@@ -52,6 +52,15 @@ use crate::rmeta::{
 pub trait MetadataLoader {
     fn get_rlib_metadata(&self, target: &Target, filename: &Path) -> Result<OwnedSlice, String>;
     fn get_dylib_metadata(&self, target: &Target, filename: &Path) -> Result<OwnedSlice, String>;
+
+    /// `(NativeLib::name, filename)` pairs from `lib.rmeta-link`. Empty when absent.
+    fn get_rlib_native_lib_filenames(
+        &self,
+        _target: &Target,
+        _filename: &Path,
+    ) -> Vec<(String, String)> {
+        Vec::new()
+    }
 }
 
 pub type MetadataLoaderDyn = dyn MetadataLoader + Send + Sync + sync::DynSend + sync::DynSync;
@@ -234,6 +243,10 @@ impl CStore {
         self.metas[cnum].as_ref().unwrap_or_else(|| panic!("Failed to get crate data for {cnum:?}"))
     }
 
+    pub(crate) fn metadata_loader(&self) -> &MetadataLoaderDyn {
+        &*self.metadata_loader
+    }
+
     pub(crate) fn get_crate_data_mut(&mut self, cnum: CrateNum) -> &mut CrateMetadata {
         self.metas[cnum].as_mut().unwrap_or_else(|| panic!("Failed to get crate data for {cnum:?}"))
     }

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1458,7 +1458,22 @@ impl CrateMetadata {
     }
 
     fn get_native_libraries(&self, tcx: TyCtxt<'_>) -> impl Iterator<Item = NativeLib> {
-        self.root.native_libraries.decode((self, tcx))
+        let mut libs: Vec<NativeLib> = self.root.native_libraries.decode((self, tcx)).collect();
+
+        if let Some(rlib_path) = self.source().rlib.as_ref() {
+            let cstore = CStore::from_tcx(tcx);
+            let filenames =
+                cstore.metadata_loader().get_rlib_native_lib_filenames(&tcx.sess.target, rlib_path);
+            for lib in libs.iter_mut() {
+                if let Some((_, filename)) =
+                    filenames.iter().find(|(name, _)| name == lib.name.as_str())
+                {
+                    lib.filename = Some(Symbol::intern(filename));
+                }
+            }
+        }
+
+        libs.into_iter()
     }
 
     fn get_proc_macro_quoted_span(&self, tcx: TyCtxt<'_>, index: usize) -> Span {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -60,7 +60,7 @@ pub(crate) fn rustc_version(cfg_version: &'static str) -> String {
 /// Metadata encoding version.
 /// N.B., increment this if you change the format of metadata such that
 /// the rustc version can't be found to compare with `rustc_version()`.
-const METADATA_VERSION: u8 = 10;
+const METADATA_VERSION: u8 = 11;
 
 /// Metadata header which includes `METADATA_VERSION`.
 ///

compiler/rustc_session/src/cstore.rs

@@ -13,7 +13,7 @@ use rustc_hir::def_id::{
 };
 use rustc_hir::definitions::{DefKey, DefPath, DefPathHash, Definitions};
 use rustc_macros::{BlobDecodable, Decodable, Encodable, StableHash};
-use rustc_span::{Span, Symbol};
+use rustc_span::{Span, SpanDecoder, SpanEncoder, Symbol};
 
 // lonely orphan structs and enums looking for a better home
 
@@ -64,18 +64,44 @@ pub enum LinkagePreference {
     RequireStatic,
 }
 
-#[derive(Debug, Encodable, Decodable, StableHash)]
+#[derive(Debug, StableHash)]
 pub struct NativeLib {
     pub kind: NativeLibKind,
     pub name: Symbol,
     /// If packed_bundled_libs enabled, actual filename of library is stored.
+    #[stable_hash(ignore)]
     pub filename: Option<Symbol>,
     pub cfg: Option<CfgEntry>,
     pub foreign_module: Option<DefId>,
     pub verbatim: Option<bool>,
     pub dll_imports: Vec<DllImport>,
 }
 
+impl<E: SpanEncoder> rustc_serialize::Encodable<E> for NativeLib {
+    fn encode(&self, s: &mut E) {
+        self.kind.encode(s);
+        self.name.encode(s);
+        self.cfg.encode(s);
+        self.foreign_module.encode(s);
+        self.verbatim.encode(s);
+        self.dll_imports.encode(s);
+    }
+}
+
+impl<D: SpanDecoder> rustc_serialize::Decodable<D> for NativeLib {
+    fn decode(d: &mut D) -> Self {
+        NativeLib {
+            kind: rustc_serialize::Decodable::decode(d),
+            name: rustc_serialize::Decodable::decode(d),
+            filename: None,
+            cfg: rustc_serialize::Decodable::decode(d),
+            foreign_module: rustc_serialize::Decodable::decode(d),
+            verbatim: rustc_serialize::Decodable::decode(d),
+            dll_imports: rustc_serialize::Decodable::decode(d),
+        }
+    }
+}
+
 impl NativeLib {
     pub fn has_modifiers(&self) -> bool {
         self.verbatim.is_some() || self.kind.has_modifiers()

tests/run-make/rlib-rmeta-link-native-lib-filenames/main.rs

@@ -0,0 +1,4 @@
+extern crate rust_dep;
+fn main() {
+    assert_eq!(rust_dep::rust_dep(), 3);
+}

tests/run-make/rlib-rmeta-link-native-lib-filenames/native_dep_a.c

@@ -0,0 +1 @@
+int native_fa() { return 1; }

tests/run-make/rlib-rmeta-link-native-lib-filenames/native_dep_b.c

@@ -0,0 +1 @@
+int native_fb() { return 2; }