src/metadata.rs

   1 use std::convert::TryFrom;
   2 use std::fs::File;
   3 use std::path::Path;
   4
   5 use rustc_codegen_ssa::METADATA_FILENAME;
   6 use rustc_data_structures::owning_ref::{self, OwningRef};
   7 use rustc_data_structures::rustc_erase_owner;
   8 use rustc_middle::middle::cstore::{EncodedMetadata, MetadataLoader};
   9 use rustc_middle::ty::TyCtxt;
  10 use rustc_session::config;
  11 use rustc_target::spec::Target;
  12
  13 use crate::backend::WriteMetadata;
  14
  15 pub(crate) struct CraneliftMetadataLoader;
  16
  17 impl MetadataLoader for CraneliftMetadataLoader {
  18     fn get_rlib_metadata(
  19         &self,
  20         _target: &Target,
  21         path: &Path,
  22     ) -> Result<owning_ref::ErasedBoxRef<[u8]>, String> {
  23         let mut archive = ar::Archive::new(File::open(path).map_err(|e| format!("{:?}", e))?);
  24         // Iterate over all entries in the archive:
  25         while let Some(entry_result) = archive.next_entry() {
  26             let mut entry = entry_result.map_err(|e| format!("{:?}", e))?;
  27             if entry.header().identifier() == METADATA_FILENAME.as_bytes() {
  28                 let mut buf = Vec::with_capacity(
  29                     usize::try_from(entry.header().size())
  30                         .expect("Rlib metadata file too big to load into memory."),
  31                 );
  32                 ::std::io::copy(&mut entry, &mut buf).map_err(|e| format!("{:?}", e))?;
  33                 let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf).into();
  34                 return Ok(rustc_erase_owner!(buf.map_owner_box()));
  35             }
  36         }
  37
  38         Err("couldn't find metadata entry".to_string())
  39         //self.get_dylib_metadata(target, path)
  40     }
  41
  42     fn get_dylib_metadata(
  43         &self,
  44         _target: &Target,
  45         path: &Path,
  46     ) -> Result<owning_ref::ErasedBoxRef<[u8]>, String> {
  47         use object::{Object, ObjectSection};
  48         let file = std::fs::read(path).map_err(|e| format!("read:{:?}", e))?;
  49         let file = object::File::parse(&file).map_err(|e| format!("parse: {:?}", e))?;
  50         let buf = file
  51             .section_by_name(".rustc")
  52             .ok_or("no .rustc section")?
  53             .data()
  54             .map_err(|e| format!("failed to read .rustc section: {:?}", e))?
  55             .to_owned();
  56         let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf).into();
  57         Ok(rustc_erase_owner!(buf.map_owner_box()))
  58     }
  59 }
  60
  61 // Adapted from https://github.com/rust-lang/rust/blob/da573206f87b5510de4b0ee1a9c044127e409bd3/src/librustc_codegen_llvm/base.rs#L47-L112
  62 pub(crate) fn write_metadata<P: WriteMetadata>(
  63     tcx: TyCtxt<'_>,
  64     product: &mut P,
  65 ) -> EncodedMetadata {
  66     use flate2::write::DeflateEncoder;
  67     use flate2::Compression;
  68     use std::io::Write;
  69
  70     #[derive(PartialEq, Eq, PartialOrd, Ord)]
  71     enum MetadataKind {
  72         None,
  73         Uncompressed,
  74         Compressed,
  75     }
  76
  77     let kind = tcx
  78         .sess
  79         .crate_types()
  80         .iter()
  81         .map(|ty| match *ty {
  82             config::CrateType::Executable
  83             | config::CrateType::Staticlib
  84             | config::CrateType::Cdylib => MetadataKind::None,
  85
  86             config::CrateType::Rlib => MetadataKind::Uncompressed,
  87
  88             config::CrateType::Dylib | config::CrateType::ProcMacro => MetadataKind::Compressed,
  89         })
  90         .max()
  91         .unwrap_or(MetadataKind::None);
  92
  93     if kind == MetadataKind::None {
  94         return EncodedMetadata::new();
  95     }
  96
  97     let metadata = tcx.encode_metadata();
  98     if kind == MetadataKind::Uncompressed {
  99         return metadata;
 100     }
 101
 102     assert!(kind == MetadataKind::Compressed);
 103     let mut compressed = tcx.metadata_encoding_version();
 104     DeflateEncoder::new(&mut compressed, Compression::fast())
 105         .write_all(&metadata.raw_data)
 106         .unwrap();
 107
 108     product.add_rustc_section(
 109         rustc_middle::middle::exported_symbols::metadata_symbol_name(tcx),
 110         compressed,
 111         tcx.sess.target.target.options.is_like_osx,
 112     );
 113
 114     metadata
 115 }