Read and write dylib metadata

Author: bjorn3

Cargo.lock

@@ -27,6 +27,7 @@ tempfile = "3.0.7"
 env_logger = "0.6"
 gimli = { git = "https://github.com/gimli-rs/gimli.git" }
 indexmap = "1.0.2"
+object = "0.11.0"
 
 # Uncomment to use local checkout of cranelift
 #[patch."https://github.com/CraneStation/cranelift.git"]

Cargo.toml

@@ -146,6 +146,35 @@ pub fn codegen_crate<'a, 'tcx>(
         rustc_incremental::save_dep_graph(tcx);
         rustc_incremental::finalize_session_directory(tcx.sess, tcx.crate_hash(LOCAL_CRATE));
 
+        let metadata_module = {
+            use rustc::mir::mono::CodegenUnitNameBuilder;
+
+            let cgu_name_builder = &mut CodegenUnitNameBuilder::new(tcx);
+            let metadata_cgu_name = cgu_name_builder
+                .build_cgu_name(LOCAL_CRATE, &["crate"], Some("metadata"))
+                .as_str()
+                .to_string();
+
+            let mut metadata_artifact =
+                faerie::Artifact::new(crate::build_isa(tcx.sess).triple().clone(), metadata_cgu_name.clone());
+            crate::metadata::write_metadata(tcx, &mut metadata_artifact);
+
+            let tmp_file = tcx
+                .output_filenames(LOCAL_CRATE)
+                .temp_path(OutputType::Metadata, Some(&metadata_cgu_name));
+
+            let obj = metadata_artifact.emit().unwrap();
+            std::fs::write(&tmp_file, obj).unwrap();
+
+            CompiledModule {
+                name: metadata_cgu_name,
+                kind: ModuleKind::Metadata,
+                object: Some(tmp_file),
+                bytecode: None,
+                bytecode_compressed: None,
+            }
+        };
+
         Box::new(CodegenResults {
             crate_name: tcx.crate_name(LOCAL_CRATE),
             modules: vec![emit_module(
@@ -164,13 +193,7 @@ pub fn codegen_crate<'a, 'tcx>(
             } else {
                 None
             },
-            metadata_module: Some(CompiledModule {
-                name: "dummy_metadata".to_string(),
-                kind: ModuleKind::Metadata,
-                object: None,
-                bytecode: None,
-                bytecode_compressed: None,
-            }),
+            metadata_module: Some(metadata_module),
             crate_hash: tcx.crate_hash(LOCAL_CRATE),
             metadata,
             windows_subsystem: None, // Windows is not yet supported

src/driver.rs

@@ -1,6 +1,7 @@
 #![feature(rustc_private, never_type, decl_macro)]
 #![allow(intra_doc_link_resolution_failure)]
 
+extern crate flate2;
 extern crate log;
 extern crate rustc;
 extern crate rustc_allocator;

src/lib.rs

@@ -1,16 +1,20 @@
-use rustc::middle::cstore::MetadataLoader;
+use std::fs::File;
+use std::path::Path;
+
+use rustc::session::config;
+use rustc::ty::TyCtxt;
+use rustc::middle::cstore::{EncodedMetadata, MetadataLoader};
 use rustc_codegen_ssa::METADATA_FILENAME;
 use rustc_data_structures::owning_ref::{self, OwningRef};
 use rustc_data_structures::rustc_erase_owner;
-use std::fs::File;
-use std::path::Path;
+use rustc_target::spec::Target;
 
 pub struct CraneliftMetadataLoader;
 
 impl MetadataLoader for CraneliftMetadataLoader {
     fn get_rlib_metadata(
         &self,
-        _target: &crate::rustc_target::spec::Target,
+        _target: &Target,
         path: &Path,
     ) -> Result<owning_ref::ErasedBoxRef<[u8]>, String> {
         let mut archive = ar::Archive::new(File::open(path).map_err(|e| format!("{:?}", e))?);
@@ -31,9 +35,62 @@ impl MetadataLoader for CraneliftMetadataLoader {
 
     fn get_dylib_metadata(
         &self,
-        _target: &crate::rustc_target::spec::Target,
-        _path: &Path,
+        _target: &Target,
+        path: &Path,
     ) -> Result<owning_ref::ErasedBoxRef<[u8]>, String> {
-        Err("dylib metadata loading is not yet supported".to_string())
+        use object::Object;
+        let file = std::fs::read(path).map_err(|e| format!("read:{:?}", e))?;
+        let file = object::File::parse(&file).map_err(|e| format!("parse: {:?}", e))?;
+        let buf = file.section_data_by_name(".rustc").ok_or("no .rustc section")?.into_owned();
+        let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf).into();
+        Ok(rustc_erase_owner!(buf.map_owner_box()))
     }
 }
+
+// Adapted from https://github.com/rust-lang/rust/blob/da573206f87b5510de4b0ee1a9c044127e409bd3/src/librustc_codegen_llvm/base.rs#L47-L112
+pub fn write_metadata<'a, 'gcx>(
+    tcx: TyCtxt<'a, 'gcx, 'gcx>,
+    artifact: &mut faerie::Artifact
+) -> EncodedMetadata {
+    use std::io::Write;
+    use flate2::Compression;
+    use flate2::write::DeflateEncoder;
+
+    #[derive(PartialEq, Eq, PartialOrd, Ord)]
+    enum MetadataKind {
+        None,
+        Uncompressed,
+        Compressed
+    }
+
+    let kind = tcx.sess.crate_types.borrow().iter().map(|ty| {
+        match *ty {
+            config::CrateType::Executable |
+            config::CrateType::Staticlib |
+            config::CrateType::Cdylib => MetadataKind::None,
+
+            config::CrateType::Rlib => MetadataKind::Uncompressed,
+
+            config::CrateType::Dylib |
+            config::CrateType::ProcMacro => MetadataKind::Compressed,
+        }
+    }).max().unwrap_or(MetadataKind::None);
+
+    if kind == MetadataKind::None {
+        return EncodedMetadata::new();
+    }
+
+    let metadata = tcx.encode_metadata();
+    if kind == MetadataKind::Uncompressed {
+        return metadata;
+    }
+
+    assert!(kind == MetadataKind::Compressed);
+    let mut compressed = tcx.metadata_encoding_version();
+    DeflateEncoder::new(&mut compressed, Compression::fast())
+        .write_all(&metadata.raw_data).unwrap();
+
+    artifact.declare_with(".rustc", faerie::Decl::debug_section(), compressed).unwrap();
+
+    metadata
+}

src/metadata.rs

@@ -5,7 +5,7 @@ rm -r target/out || true
 mkdir -p target/out/clif
 
 echo "[BUILD] mini_core"
-$RUSTC example/mini_core.rs --crate-name mini_core --crate-type lib
+$RUSTC example/mini_core.rs --crate-name mini_core --crate-type dylib
 
 echo "[BUILD] example"
 $RUSTC example/example.rs --crate-type lib