Auto merge of #145893 - bjorn3:lto_less_copying, r=<try>

Avoid copying the bitcode out of rlibs

Author: rust-bors[bot]

compiler/rustc_codegen_gcc/src/back/lto.rs

@@ -234,10 +234,7 @@ fn fat_lto(
                         .context
                         .add_driver_option(module_buffer.0.to_str().expect("path"));
                 }
-                SerializedModule::FromRlib(_) => unimplemented!("from rlib"),
-                SerializedModule::FromUncompressedFile(_) => {
-                    unimplemented!("from uncompressed file")
-                }
+                SerializedModule::FromFile(_) => unimplemented!("from file"),
             }
         }
         save_temp_bitcode(cgcx, &module, "lto.input");
@@ -417,10 +414,7 @@ fn thin_lto(
                 .context
                 .add_driver_option(module_buffer.0.to_str().expect("path"));*/
             }
-            SerializedModule::FromRlib(_) => unimplemented!("from rlib"),
-            SerializedModule::FromUncompressedFile(_) => {
-                unimplemented!("from uncompressed file")
-            }
+            SerializedModule::FromFile(_) => unimplemented!("from file"),
         }
 
         serialized.push(module);
@@ -554,10 +548,7 @@ pub fn optimize_thin_module(
                         .context
                         .add_driver_option(module_buffer.0.to_str().expect("path"));*/
                 }
-                SerializedModule::FromRlib(_) => unimplemented!("from rlib"),
-                SerializedModule::FromUncompressedFile(_) => {
-                    unimplemented!("from uncompressed file")
-                }
+                SerializedModule::FromFile(_) => unimplemented!("from file"),
             }
             Arc::new(SyncContext::new(context))
         }

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -14,6 +14,7 @@ use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::{ModuleCodegen, ModuleKind, looks_like_rust_object_file};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::memmap::Mmap;
+use rustc_data_structures::owned_slice::{OwnedSlice, slice_owned};
 use rustc_errors::DiagCtxtHandle;
 use rustc_middle::bug;
 use rustc_middle::dep_graph::WorkProduct;
@@ -56,10 +57,13 @@ fn prepare_lto(
     let mut upstream_modules = Vec::new();
     if cgcx.lto != Lto::ThinLocal {
         for path in each_linked_rlib_for_lto {
-            let archive_data = unsafe {
-                Mmap::map(std::fs::File::open(&path).expect("couldn't open rlib"))
-                    .expect("couldn't map rlib")
-            };
+            let archive_data = slice_owned(
+                unsafe {
+                    Mmap::map(std::fs::File::open(&path).expect("couldn't open rlib"))
+                        .expect("couldn't map rlib")
+                },
+                |data| &*data,
+            );
             let archive = ArchiveFile::parse(&*archive_data).expect("wanted an rlib");
             let obj_files = archive
                 .members()
@@ -71,12 +75,14 @@ fn prepare_lto(
                 .filter(|&(name, _)| looks_like_rust_object_file(name));
             for (name, child) in obj_files {
                 info!("adding bitcode from {}", name);
-                match get_bitcode_slice_from_object_data(
-                    child.data(&*archive_data).expect("corrupt rlib"),
-                    cgcx,
-                ) {
+                let (offset, size) = child.file_range();
+                let child_data = archive_data.clone().slice(|data| {
+                    data.get(offset as usize..offset as usize + size as usize)
+                        .expect("corrupt rlib")
+                });
+                match get_bitcode_slice_from_object_data(child_data, cgcx) {
                     Ok(data) => {
-                        let module = SerializedModule::FromRlib(data.to_vec());
+                        let module = SerializedModule::FromFile(data);
                         upstream_modules.push((module, CString::new(name).unwrap()));
                     }
                     Err(e) => dcx.emit_fatal(e),
@@ -88,29 +94,33 @@ fn prepare_lto(
     (symbols_below_threshold, upstream_modules)
 }
 
-fn get_bitcode_slice_from_object_data<'a>(
-    obj: &'a [u8],
+fn get_bitcode_slice_from_object_data(
+    data: OwnedSlice,
     cgcx: &CodegenContext<LlvmCodegenBackend>,
-) -> Result<&'a [u8], LtoBitcodeFromRlib> {
+) -> Result<OwnedSlice, LtoBitcodeFromRlib> {
     // We're about to assume the data here is an object file with sections, but if it's raw LLVM IR
     // that won't work. Fortunately, if that's what we have we can just return the object directly,
     // so we sniff the relevant magic strings here and return.
-    if obj.starts_with(b"\xDE\xC0\x17\x0B") || obj.starts_with(b"BC\xC0\xDE") {
-        return Ok(obj);
+    if data.starts_with(b"\xDE\xC0\x17\x0B") || data.starts_with(b"BC\xC0\xDE") {
+        return Ok(data);
     }
     // We drop the "__LLVM," prefix here because on Apple platforms there's a notion of "segment
     // name" which in the public API for sections gets treated as part of the section name, but
     // internally in MachOObjectFile.cpp gets treated separately.
     let section_name = bitcode_section_name(cgcx).to_str().unwrap().trim_start_matches("__LLVM,");
 
     let obj =
-        object::File::parse(obj).map_err(|err| LtoBitcodeFromRlib { err: err.to_string() })?;
+        object::File::parse(&*data).map_err(|err| LtoBitcodeFromRlib { err: err.to_string() })?;
 
     let section = obj
         .section_by_name(section_name)
         .ok_or_else(|| LtoBitcodeFromRlib { err: format!("Can't find section {section_name}") })?;
 
-    section.data().map_err(|err| LtoBitcodeFromRlib { err: err.to_string() })
+    if let Some((offset, size)) = section.file_range() {
+        Ok(data.slice(|data| &data[offset as usize..offset as usize + size as usize]))
+    } else {
+        Err(LtoBitcodeFromRlib { err: format!("Section {section_name} doesn't have contents") })
+    }
 }
 
 /// Performs fat LTO by merging all modules into a single one and returning it

compiler/rustc_codegen_ssa/src/back/lto.rs

@@ -1,7 +1,7 @@
 use std::ffi::CString;
 use std::sync::Arc;
 
-use rustc_data_structures::memmap::Mmap;
+use rustc_data_structures::owned_slice::OwnedSlice;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportLevel};
 use rustc_middle::ty::TyCtxt;
@@ -47,16 +47,14 @@ pub struct ThinShared<B: WriteBackendMethods> {
 
 pub enum SerializedModule<M: ModuleBufferMethods> {
     Local(M),
-    FromRlib(Vec<u8>),
-    FromUncompressedFile(Mmap),
+    FromFile(OwnedSlice),
 }
 
 impl<M: ModuleBufferMethods> SerializedModule<M> {
     pub fn data(&self) -> &[u8] {
         match *self {
             SerializedModule::Local(ref m) => m.data(),
-            SerializedModule::FromRlib(ref m) => m,
-            SerializedModule::FromUncompressedFile(ref m) => m,
+            SerializedModule::FromFile(ref m) => m,
         }
     }
 }

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -11,6 +11,7 @@ use rustc_ast::attr;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::jobserver::{self, Acquired};
 use rustc_data_structures::memmap::Mmap;
+use rustc_data_structures::owned_slice::slice_owned;
 use rustc_data_structures::profiling::{SelfProfilerRef, VerboseTimingGuard};
 use rustc_errors::emitter::Emitter;
 use rustc_errors::translation::Translator;
@@ -2061,7 +2062,7 @@ pub(crate) fn submit_pre_lto_module_to_llvm<B: ExtraBackendMethods>(
     };
     // Schedule the module to be loaded
     drop(coordinator.sender.send(Message::AddImportOnlyModule::<B> {
-        module_data: SerializedModule::FromUncompressedFile(mmap),
+        module_data: SerializedModule::FromFile(slice_owned(mmap, |mmap| &*mmap)),
         work_product: module.source,
     }));
 }