Unrolled build for #157263

rust-timer · web-flow · commit 67d3467cce47 · 2026-06-03T18:29:47.000+02:00
Rollup merge of #157263 - petrochenkov:arentry, r=bjorn3 rustc_codegen_ssa: Refactor `ArchiveEntry` to include entry kind Needed for #155338 in particular. r? @bjorn3
diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -21,7 +21,7 @@ use rustc_target::spec::Arch;
 use tracing::trace;
 
 use super::metadata::{create_compressed_metadata_file, search_for_section};
-use super::rmeta_link::{self, RmetaLink};
+use super::rmeta_link;
 use crate::common;
 // Public for ArchiveBuilderBuilder::extract_bundled_libs
 pub use crate::errors::ExtractBundledLibsError;
@@ -308,14 +308,15 @@ fn find_binutils_dlltool(sess: &Session) -> OsString {
     tool_name
 }
 
+pub enum AddArchiveKind<'a> {
+    Rlib(/*skip*/ &'a dyn Fn(&str, ArchiveEntryKind) -> bool),
+    Other,
+}
+
 pub trait ArchiveBuilder {
-    fn add_file(&mut self, path: &Path);
+    fn add_file(&mut self, path: &Path, kind: ArchiveEntryKind);
 
-    fn add_archive(
-        &mut self,
-        archive: &Path,
-        skip: Option<Box<dyn FnMut(&str, Option<&RmetaLink>) -> bool + 'static>>,
-    ) -> io::Result<()>;
+    fn add_archive(&mut self, archive: &Path, kind: AddArchiveKind<'_>) -> io::Result<()>;
 
     fn build(self: Box<Self>, output: &Path) -> bool;
 }
@@ -383,12 +384,27 @@ pub struct ArArchiveBuilder<'a> {
     entries: Vec<(Vec<u8>, ArchiveEntry)>,
 }
 
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum ArchiveEntryKind {
+    /// Object file produced from Rust code.
+    RustObj,
+    /// Anything else, introduce new variants as needed.
+    Other,
+}
+
 #[derive(Debug)]
-enum ArchiveEntry {
-    FromArchive { archive_index: usize, file_range: (u64, u64) },
+enum ArchiveEntrySource {
+    Archive { archive_index: usize, file_range: (u64, u64) },
     File(PathBuf),
 }
 
+#[derive(Debug)]
+struct ArchiveEntry {
+    source: ArchiveEntrySource,
+    #[expect(dead_code)] // used in #155338
+    kind: ArchiveEntryKind,
+}
+
 impl<'a> ArArchiveBuilder<'a> {
     pub fn new(sess: &'a Session, object_reader: &'static ObjectReader) -> ArArchiveBuilder<'a> {
         ArArchiveBuilder { sess, object_reader, src_archives: vec![], entries: vec![] }
@@ -443,11 +459,7 @@ pub fn try_extract_macho_fat_archive(
 }
 
 impl<'a> ArchiveBuilder for ArArchiveBuilder<'a> {
-    fn add_archive(
-        &mut self,
-        archive_path: &Path,
-        mut skip: Option<Box<dyn FnMut(&str, Option<&RmetaLink>) -> bool + 'static>>,
-    ) -> io::Result<()> {
+    fn add_archive(&mut self, archive_path: &Path, ar_kind: AddArchiveKind<'_>) -> io::Result<()> {
         let mut archive_path = archive_path.to_path_buf();
         if self.sess.target.llvm_target.contains("-apple-macosx")
             && let Some(new_archive_path) = try_extract_macho_fat_archive(self.sess, &archive_path)?
@@ -462,8 +474,10 @@ impl<'a> ArchiveBuilder for ArArchiveBuilder<'a> {
         let archive_map = unsafe { Mmap::map(File::open(&archive_path)?)? };
         let archive = ArchiveFile::parse(&*archive_map)
             .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
-        let metadata_link =
-            skip.as_ref().and_then(|_| rmeta_link::read(&archive, &archive_map, &archive_path));
+        let metadata_link = match ar_kind {
+            AddArchiveKind::Rlib(..) => rmeta_link::read(&archive, &archive_map, &archive_path),
+            AddArchiveKind::Other => None,
+        };
         let archive_index = self.src_archives.len();
 
         if let Some(expected_kind) =
@@ -483,17 +497,26 @@ impl<'a> ArchiveBuilder for ArArchiveBuilder<'a> {
             let entry = entry.map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
             let file_name = String::from_utf8(entry.name().to_vec())
                 .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
-            let drop = skip.as_mut().is_some_and(|f| f(&file_name, metadata_link.as_ref()));
+            let kind = if metadata_link
+                .as_ref()
+                .is_some_and(|m| m.rust_object_files.iter().any(|f| f == &file_name))
+            {
+                ArchiveEntryKind::RustObj
+            } else {
+                ArchiveEntryKind::Other
+            };
+            let drop = match ar_kind {
+                AddArchiveKind::Rlib(skip) => skip(&file_name, kind),
+                AddArchiveKind::Other => false,
+            };
             if !drop {
-                if entry.is_thin() {
+                let source = if entry.is_thin() {
                     let member_path = archive_path.parent().unwrap().join(Path::new(&file_name));
-                    self.entries.push((file_name.into_bytes(), ArchiveEntry::File(member_path)));
+                    ArchiveEntrySource::File(member_path)
                 } else {
-                    self.entries.push((
-                        file_name.into_bytes(),
-                        ArchiveEntry::FromArchive { archive_index, file_range: entry.file_range() },
-                    ));
-                }
+                    ArchiveEntrySource::Archive { archive_index, file_range: entry.file_range() }
+                };
+                self.entries.push((file_name.into_bytes(), ArchiveEntry { source, kind }));
             }
         }
 
@@ -502,10 +525,10 @@ impl<'a> ArchiveBuilder for ArArchiveBuilder<'a> {
     }
 
     /// Adds an arbitrary file to this archive
-    fn add_file(&mut self, file: &Path) {
+    fn add_file(&mut self, file: &Path, kind: ArchiveEntryKind) {
         self.entries.push((
             file.file_name().unwrap().to_str().unwrap().to_string().into_bytes(),
-            ArchiveEntry::File(file.to_owned()),
+            ArchiveEntry { source: ArchiveEntrySource::File(file.to_owned()), kind },
         ));
     }
 
@@ -539,8 +562,8 @@ impl<'a> ArArchiveBuilder<'a> {
 
         for (entry_name, entry) in self.entries {
             let data =
-                match entry {
-                    ArchiveEntry::FromArchive { archive_index, file_range } => {
+                match entry.source {
+                    ArchiveEntrySource::Archive { archive_index, file_range } => {
                         let src_archive = &self.src_archives[archive_index];
                         let archive_data = &src_archive.1;
                         let start = file_range.0 as usize;
@@ -563,7 +586,7 @@ impl<'a> ArArchiveBuilder<'a> {
 
                         Box::new(data) as Box<dyn AsRef<[u8]>>
                     }
-                    ArchiveEntry::File(file) => unsafe {
+                    ArchiveEntrySource::File(file) => unsafe {
                         Box::new(
                             Mmap::map(File::open(file).map_err(|err| {
                                 io_error_context("failed to open object file", err)
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -53,7 +53,7 @@ use rustc_target::spec::{
 };
 use tracing::{debug, info, warn};
 
-use super::archive::{ArchiveBuilder, ArchiveBuilderBuilder};
+use super::archive::{AddArchiveKind, ArchiveBuilder, ArchiveBuilderBuilder, ArchiveEntryKind};
 use super::command::Command;
 use super::linker::{self, Linker};
 use super::metadata::{MetadataPosition, create_wrapper_file};
@@ -342,11 +342,11 @@ fn link_rlib<'a>(
                     // normal linkers for the platform. Sometimes this is not possible however.
                     // If it is possible however, placing the metadata object first improves
                     // performance of getting metadata from rlibs.
-                    ab.add_file(&metadata);
+                    ab.add_file(&metadata, ArchiveEntryKind::Other);
                     // Place the rmeta-link member immediately after metadata so consumers
                     // can find it without iterating the whole archive.
                     if let Some(file) = &metadata_link_file {
-                        ab.add_file(file);
+                        ab.add_file(file, ArchiveEntryKind::Other);
                     }
                     None
                 }
@@ -359,15 +359,15 @@ fn link_rlib<'a>(
 
     for m in &compiled_modules.modules {
         if let Some(obj) = m.object.as_ref() {
-            ab.add_file(obj);
+            ab.add_file(obj, ArchiveEntryKind::RustObj);
         }
 
         if let Some(obj) = m.global_asm_object.as_ref() {
-            ab.add_file(obj);
+            ab.add_file(obj, ArchiveEntryKind::RustObj);
         }
 
         if let Some(dwarf_obj) = m.dwarf_object.as_ref() {
-            ab.add_file(dwarf_obj);
+            ab.add_file(dwarf_obj, ArchiveEntryKind::Other);
         }
     }
 
@@ -376,10 +376,10 @@ fn link_rlib<'a>(
         RlibFlavor::StaticlibBase => {
             if let Some(m) = &compiled_modules.allocator_module {
                 if let Some(obj) = &m.object {
-                    ab.add_file(obj);
+                    ab.add_file(obj, ArchiveEntryKind::RustObj);
                 }
                 if let Some(obj) = &m.global_asm_object {
-                    ab.add_file(obj);
+                    ab.add_file(obj, ArchiveEntryKind::RustObj);
                 }
             }
         }
@@ -419,7 +419,7 @@ fn link_rlib<'a>(
             packed_bundled_libs.push(wrapper_file);
         } else {
             let path = find_native_static_library(lib.name.as_str(), lib.verbatim, sess);
-            ab.add_archive(&path, None).unwrap_or_else(|error| {
+            ab.add_archive(&path, AddArchiveKind::Other).unwrap_or_else(|error| {
                 sess.dcx().emit_fatal(errors::AddNativeLibrary { library_path: path, error })
             });
         }
@@ -436,7 +436,7 @@ fn link_rlib<'a>(
             tmpdir.as_ref(),
             true,
         ) {
-            ab.add_archive(&output_path, None).unwrap_or_else(|error| {
+            ab.add_archive(&output_path, AddArchiveKind::Other).unwrap_or_else(|error| {
                 sess.dcx()
                     .emit_fatal(errors::AddNativeLibrary { library_path: output_path, error });
             });
@@ -469,18 +469,18 @@ fn link_rlib<'a>(
         //
         // Basically, all this means is that this code should not move above the
         // code above.
-        ab.add_file(&trailing_metadata);
+        ab.add_file(&trailing_metadata, ArchiveEntryKind::Other);
         // Place the rmeta-link member immediately after metadata so consumers can
         // find it without iterating the whole archive.
         if let Some(file) = &metadata_link_file {
-            ab.add_file(file);
+            ab.add_file(file, ArchiveEntryKind::Other);
         }
     }
 
     // Add all bundled static native library dependencies.
     // Archives added to the end of .rlib archive, see comment above for the reason.
     for lib in packed_bundled_libs {
-        ab.add_file(&lib)
+        ab.add_file(&lib, ArchiveEntryKind::Other)
     }
 
     ab
@@ -529,16 +529,14 @@ fn link_staticlib(
         let bundled_libs: FxIndexSet<_> = native_libs.filter_map(|lib| lib.filename).collect();
         ab.add_archive(
             path,
-            Some(Box::new(move |fname: &str, metadata_link| {
+            AddArchiveKind::Rlib(&|fname: &str, entry_kind| {
                 // Ignore metadata and rmeta-link files.
                 if fname == METADATA_FILENAME || fname == rmeta_link::FILENAME {
                     return true;
                 }
 
                 // Don't include Rust objects if LTO is enabled.
-                if lto
-                    && metadata_link.is_some_and(|m| m.rust_object_files.iter().any(|f| f == fname))
-                {
+                if lto && entry_kind == ArchiveEntryKind::RustObj {
                     return true;
                 }
 
@@ -548,7 +546,7 @@ fn link_staticlib(
                 }
 
                 false
-            })),
+            }),
         )
         .unwrap();
 
@@ -559,7 +557,7 @@ fn link_staticlib(
         for filename in relevant_libs.iter() {
             let joined = tempdir.as_ref().join(filename.as_str());
             let path = joined.as_path();
-            ab.add_archive(path, None).unwrap();
+            ab.add_archive(path, AddArchiveKind::Other).unwrap();
         }
 
         all_native_libs.extend(crate_info.native_libraries[&cnum].iter().cloned());
@@ -1266,7 +1264,7 @@ fn link_natively(
 
     if should_archive {
         let mut ab = archive_builder_builder.new_archive_builder(sess);
-        ab.add_file(temp_filename);
+        ab.add_file(temp_filename, ArchiveEntryKind::Other);
         ab.build(out_filename);
     }
 }
@@ -3242,19 +3240,19 @@ fn add_static_crate(
         let mut archive = archive_builder_builder.new_archive_builder(sess);
         if let Err(error) = archive.add_archive(
             cratepath,
-            Some(Box::new(move |f, metadata_link| {
+            AddArchiveKind::Rlib(&|f, entry_kind| {
                 if f == METADATA_FILENAME || f == rmeta_link::FILENAME {
                     return true;
                 }
 
-                let is_rust_object =
-                    metadata_link.is_some_and(|m| m.rust_object_files.iter().any(|rf| rf == f));
-
                 // If we're performing LTO and this is a rust-generated object
                 // file, then we don't need the object file as it's part of the
                 // LTO module. Note that `#![no_builtins]` is excluded from LTO,
                 // though, so we let that object file slide.
-                if upstream_rust_objects_already_included && is_rust_object && is_builtins {
+                if upstream_rust_objects_already_included
+                    && entry_kind == ArchiveEntryKind::RustObj
+                    && is_builtins
+                {
                     return true;
                 }
 
@@ -3268,7 +3266,7 @@ fn add_static_crate(
                 }
 
                 false
-            })),
+            }),
         ) {
             sess.dcx()
                 .emit_fatal(errors::RlibArchiveBuildFailure { path: cratepath.clone(), error });
