src/metadata.rs

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