Introduce -Zsplit-metadata option

This will split the crate metadata out of library files. Instead only
the svh is preserved to allow for loading the right rmeta file. This
significicantly reduces library size. In addition it allows for cheaper
checks if different library files are the same crate.

Author: bjorn3

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -359,7 +359,7 @@ fn link_rlib<'a, B: ArchiveBuilder<'a>>(
             // metadata in rlib files is wrapped in a "dummy" object file for
             // the target platform so the rlib can be processed entirely by
             // normal linkers for the platform.
-            let metadata = create_rmeta_file(sess, codegen_results.metadata.raw_data());
+            let metadata = create_rmeta_file(sess, codegen_results.metadata.maybe_reference());
             ab.add_file(&emit_metadata(sess, &metadata, tmpdir));
         }
 

compiler/rustc_codegen_ssa/src/back/metadata.rs

@@ -252,6 +252,7 @@ pub fn create_rmeta_file(sess: &Session, metadata: &[u8]) -> Vec<u8> {
 // As a result, we choose a slightly shorter name! As to why
 // `.note.rustc` works on MinGW, see
 // https://github.com/llvm/llvm-project/blob/llvmorg-12.0.0/lld/COFF/Writer.cpp#L1190-L1197
+// TODO rename function
 pub fn create_compressed_metadata_file(
     sess: &Session,
     metadata: &EncodedMetadata,
@@ -260,7 +261,7 @@ pub fn create_compressed_metadata_file(
     let mut file = if let Some(file) = create_object_file(sess) {
         file
     } else {
-        return metadata.raw_data().to_vec();
+        return metadata.maybe_reference().to_vec();
     };
     let section = file.add_section(
         file.segment_name(StandardSegment::Data).to_vec(),
@@ -274,14 +275,14 @@ pub fn create_compressed_metadata_file(
         }
         _ => {}
     };
-    let offset = file.append_section_data(section, metadata.raw_data(), 1);
+    let offset = file.append_section_data(section, metadata.maybe_reference(), 1);
 
     // For MachO and probably PE this is necessary to prevent the linker from throwing away the
     // .rustc section. For ELF this isn't necessary, but it also doesn't harm.
     file.add_symbol(Symbol {
         name: symbol_name.as_bytes().to_vec(),
         value: offset,
-        size: metadata.raw_data().len() as u64,
+        size: metadata.maybe_reference().len() as u64,
         kind: SymbolKind::Data,
         scope: SymbolScope::Dynamic,
         weak: false,

compiler/rustc_interface/src/passes.rs

@@ -1036,7 +1036,7 @@ fn encode_and_write_metadata(
     enum MetadataKind {
         None,
         Uncompressed,
-        Compressed,
+        Compressed, // TODO remove this variant
     }
 
     let metadata_kind = tcx
@@ -1074,7 +1074,7 @@ fn encode_and_write_metadata(
             .tempdir_in(out_filename.parent().unwrap())
             .unwrap_or_else(|err| tcx.sess.fatal(&format!("couldn't create a temp dir: {}", err)));
         let metadata_tmpdir = MaybeTempDir::new(metadata_tmpdir, tcx.sess.opts.cg.save_temps);
-        let metadata_filename = emit_metadata(tcx.sess, metadata.raw_data(), &metadata_tmpdir);
+        let metadata_filename = emit_metadata(tcx.sess, metadata.full(), &metadata_tmpdir);
         if let Err(e) = util::non_durable_rename(&metadata_filename, &out_filename) {
             tcx.sess.fatal(&format!("failed to write {}: {}", out_filename.display(), e));
         }

compiler/rustc_interface/src/tests.rs

@@ -689,6 +689,7 @@ fn test_debugging_options_tracking_hash() {
     untracked!(self_profile_events, Some(vec![String::new()]));
     untracked!(span_debug, true);
     untracked!(span_free_formats, true);
+    untracked!(split_metadata, true);
     untracked!(temps_dir, Some(String::from("abc")));
     untracked!(terminal_width, Some(80));
     untracked!(threads, 99);

compiler/rustc_metadata/src/locator.rs

@@ -539,6 +539,11 @@ impl<'a> CrateLocator<'a> {
                 match get_metadata_section(self.target, flavor, &lib, self.metadata_loader) {
                     Ok(blob) => {
                         if let Some(h) = self.crate_matches(&blob, &lib) {
+                            if blob.is_reference_only() {
+                                if slot.is_none() {
+                                    todo!("return error");
+                                }
+                            }
                             (h, blob)
                         } else {
                             info!("metadata mismatch");
@@ -603,6 +608,19 @@ impl<'a> CrateLocator<'a> {
     }
 
     fn crate_matches(&mut self, metadata: &MetadataBlob, libpath: &Path) -> Option<Svh> {
+        if metadata.is_reference_only() {
+            let hash = metadata.get_hash();
+            if let Some(expected_hash) = self.hash {
+                if hash != expected_hash {
+                    info!("Rejecting via hash: expected {} got {}", expected_hash, hash);
+                    self.crate_rejections
+                        .via_hash
+                        .push(CrateMismatch { path: libpath.to_path_buf(), got: hash.to_string() });
+                    return None;
+                }
+            }
+        }
+
         let root = metadata.get_root();
         if root.is_proc_macro_crate() != self.is_proc_macro {
             info!(

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -628,30 +628,56 @@ impl<'tcx> MetadataBlob {
 
     crate fn check_compatibility(&self) -> Result<(), String> {
         if !self.blob().starts_with(METADATA_HEADER) {
-            if self.blob().starts_with(b"rust") {
+            if self.blob().starts_with(PREV_METADATA_HEADER) {
+                let found_version = Lazy::<String>::from_position(
+                    NonZeroUsize::new(PREV_METADATA_HEADER.len() + 4).unwrap(),
+                )
+                .decode(self);
+                return Err(found_version);
+            } else if self.blob().starts_with(b"rust") {
                 return Err("<unknown rustc version>".to_string());
             }
             return Err("<invalid metadata header>".to_string());
         }
 
-        let found_version =
-            Lazy::<String>::from_position(NonZeroUsize::new(METADATA_HEADER.len() + 4).unwrap())
-                .decode(self);
+        let found_version = Lazy::<String>::from_position(
+            NonZeroUsize::new(METADATA_HEADER.len() + 8 + 4 + 4).unwrap(),
+        )
+        .decode(self);
         if rustc_version() != found_version {
             return Err(found_version);
         }
 
         Ok(())
     }
 
+    crate fn is_reference_only(&self) -> bool {
+        let slice = &self.blob()[..];
+        let offset = METADATA_HEADER.len() + 8;
+        let pos = u32::from_le_bytes(slice[offset..offset + 4].try_into().unwrap());
+        pos == 0
+    }
+
+    crate fn get_hash(&self) -> Svh {
+        let slice = &self.blob()[..];
+        let offset = METADATA_HEADER.len() + 4;
+        Svh::new(u64::from_le_bytes(slice[offset..offset + 8].try_into().unwrap()))
+    }
+
     crate fn get_root(&self) -> CrateRoot<'tcx> {
         let slice = &self.blob()[..];
-        let offset = METADATA_HEADER.len();
+        let offset = METADATA_HEADER.len() + 8;
         let pos = (u32::from_le_bytes(slice[offset..offset + 4].try_into().unwrap())) as usize;
+        assert_ne!(pos, 0, "Tried to get crate root for reference-only metadata");
         Lazy::<CrateRoot<'tcx>>::from_position(NonZeroUsize::new(pos).unwrap()).decode(self)
     }
 
     crate fn list_crate_metadata(&self, out: &mut dyn io::Write) -> io::Result<()> {
+        if self.is_reference_only() {
+            writeln!(out, "Split metadata crate hash {}", self.get_hash())?;
+            return Ok(());
+        }
+
         let root = self.get_root();
         writeln!(out, "Crate info:")?;
         writeln!(out, "name {}{}", root.name, root.extra_filename)?;

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -2136,18 +2136,24 @@ fn prefetch_mir(tcx: TyCtxt<'_>) {
 
 #[derive(Encodable, Decodable)]
 pub struct EncodedMetadata {
-    raw_data: Vec<u8>,
+    full: Vec<u8>,
+    reference: Option<Vec<u8>>,
 }
 
 impl EncodedMetadata {
     #[inline]
     pub fn new() -> EncodedMetadata {
-        EncodedMetadata { raw_data: Vec::new() }
+        EncodedMetadata { full: Vec::new(), reference: None }
     }
 
     #[inline]
-    pub fn raw_data(&self) -> &[u8] {
-        &self.raw_data
+    pub fn full(&self) -> &[u8] {
+        &self.full
+    }
+
+    #[inline]
+    pub fn maybe_reference(&self) -> &[u8] {
+        self.reference.as_ref().unwrap_or(&self.full)
     }
 }
 
@@ -2173,20 +2179,26 @@ pub fn encode_metadata(tcx: TyCtxt<'_>) -> EncodedMetadata {
     .0
 }
 
-fn encode_metadata_impl(tcx: TyCtxt<'_>) -> EncodedMetadata {
+fn encode_metadata_header<'a, 'tcx>(
+    tcx: TyCtxt<'tcx>,
+    hygiene_ctxt: &'a HygieneEncodeContext,
+) -> EncodeContext<'a, 'tcx> {
     let mut encoder = opaque::Encoder::new(vec![]);
     encoder.emit_raw_bytes(METADATA_HEADER).unwrap();
 
+    encoder.emit_raw_bytes(&tcx.crate_hash(LOCAL_CRATE).as_u64().to_le_bytes()).unwrap();
+
     // Will be filled with the root position after encoding everything.
     encoder.emit_raw_bytes(&[0, 0, 0, 0]).unwrap();
 
+    // Reserved for future extension
+    encoder.emit_raw_bytes(&[0, 0, 0, 0]).unwrap();
+
     let source_map_files = tcx.sess.source_map().files();
     let source_file_cache = (source_map_files[0].clone(), 0);
     let required_source_files = Some(GrowableBitSet::with_capacity(source_map_files.len()));
     drop(source_map_files);
 
-    let hygiene_ctxt = HygieneEncodeContext::default();
-
     let mut ecx = EncodeContext {
         opaque: encoder,
         tcx,
@@ -2199,27 +2211,43 @@ fn encode_metadata_impl(tcx: TyCtxt<'_>) -> EncodedMetadata {
         interpret_allocs: Default::default(),
         required_source_files,
         is_proc_macro: tcx.sess.crate_types().contains(&CrateType::ProcMacro),
-        hygiene_ctxt: &hygiene_ctxt,
+        hygiene_ctxt,
     };
 
     // Encode the rustc version string in a predictable location.
     rustc_version().encode(&mut ecx).unwrap();
 
+    ecx
+}
+
+fn encode_metadata_impl(tcx: TyCtxt<'_>) -> EncodedMetadata {
+    let hygiene_ctxt = HygieneEncodeContext::default();
+    let mut ecx = encode_metadata_header(tcx, &hygiene_ctxt);
+
     // Encode all the entries and extra information in the crate,
     // culminating in the `CrateRoot` which points to all of it.
     let root = ecx.encode_crate_root();
 
     let mut result = ecx.opaque.into_inner();
 
     // Encode the root position.
-    let header = METADATA_HEADER.len();
+    let header = METADATA_HEADER.len() + 8;
     let pos = root.position.get();
     result[header..header + 4].copy_from_slice(&pos.to_le_bytes());
 
     // Record metadata size for self-profiling
     tcx.prof.artifact_size("crate_metadata", "crate_metadata", result.len() as u64);
 
-    EncodedMetadata { raw_data: result }
+    let reference_result = if tcx.sess.opts.debugging_opts.split_metadata {
+        let hygiene_ctxt = HygieneEncodeContext::default();
+        let ecx = encode_metadata_header(tcx, &hygiene_ctxt);
+        // Don't fill in the root position for reference metadata
+        Some(ecx.opaque.into_inner())
+    } else {
+        None
+    };
+
+    EncodedMetadata { full: result, reference: reference_result }
 }
 
 pub fn provide(providers: &mut Providers) {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -54,11 +54,30 @@ const METADATA_VERSION: u8 = 6;
 
 /// Metadata header which includes `METADATA_VERSION`.
 ///
-/// This header is followed by the position of the `CrateRoot`,
-/// which is encoded as a 32-bit big-endian unsigned integer,
-/// and further followed by the rustc version string.
+/// # Format
+///
+/// |field   |size    |
+/// |--------|--------|
+/// |magic   |8       |
+/// |svh     |8       |
+/// |root    |4       |
+/// |reserved|4       |
+/// |version |variable|
 pub const METADATA_HEADER: &[u8] = &[b'r', b'u', b's', b't', 0, 0, 0, METADATA_VERSION];
 
+/// The previous metadata header.
+///
+/// This is only used for reporting the rustc version of the incompatible crate.
+///
+/// # Format
+///
+/// |field  |size    |
+/// |-------|--------|
+/// |magic  |8       |
+/// |root   |4       |
+/// |version|variable|
+pub const PREV_METADATA_HEADER: &[u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 5];
+
 /// Additional metadata for a `Lazy<T>` where `T` may not be `Sized`,
 /// e.g. for `Lazy<[T]>`, this is the length (count of `T` values).
 trait LazyMeta {

compiler/rustc_session/src/options.rs

@@ -1427,6 +1427,8 @@ options! {
     split_dwarf_inlining: bool = (true, parse_bool, [UNTRACKED],
         "provide minimal debug info in the object/executable to facilitate online \
          symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF"),
+    split_metadata: bool = (false, parse_bool, [UNTRACKED],
+        "split metadata out of libraries into .rmeta files"),
     symbol_mangling_version: Option<SymbolManglingVersion> = (None,
         parse_symbol_mangling_version, [TRACKED],
         "which mangling version to use for symbol names ('legacy' (default) or 'v0')"),