compiler/rustc_codegen_cranelift/src/metadata.rs

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