compiler/rustc_data_structures/src/memmap.rs

   1 use std::fs::File;
   2 use std::io;
   3 use std::ops::{Deref, DerefMut};
   4
   5 use crate::owning_ref::StableAddress;
   6
   7 /// A trivial wrapper for [`memmap2::Mmap`] that implements [`StableAddress`].
   8 #[cfg(not(target_arch = "wasm32"))]
   9 pub struct Mmap(memmap2::Mmap);
  10
  11 #[cfg(target_arch = "wasm32")]
  12 pub struct Mmap(Vec<u8>);
  13
  14 #[cfg(not(target_arch = "wasm32"))]
  15 impl Mmap {
  16     #[inline]
  17     pub unsafe fn map(file: File) -> io::Result<Self> {
  18         memmap2::Mmap::map(&file).map(Mmap)
  19     }
  20 }
  21
  22 #[cfg(target_arch = "wasm32")]
  23 impl Mmap {
  24     #[inline]
  25     pub unsafe fn map(mut file: File) -> io::Result<Self> {
  26         use std::io::Read;
  27
  28         let mut data = Vec::new();
  29         file.read_to_end(&mut data)?;
  30         Ok(Mmap(data))
  31     }
  32 }
  33
  34 impl Deref for Mmap {
  35     type Target = [u8];
  36
  37     #[inline]
  38     fn deref(&self) -> &[u8] {
  39         &self.0
  40     }
  41 }
  42
  43 impl AsRef<[u8]> for Mmap {
  44     fn as_ref(&self) -> &[u8] {
  45         &*self.0
  46     }
  47 }
  48
  49 // SAFETY: On architectures other than WASM, mmap is used as backing storage. The address of this
  50 // memory map is stable. On WASM, `Vec<u8>` is used as backing storage. The `Mmap` type doesn't
  51 // export any function that can cause the `Vec` to be re-allocated. As such the address of the
  52 // bytes inside this `Vec` is stable.
  53 unsafe impl StableAddress for Mmap {}
  54
  55 #[cfg(not(target_arch = "wasm32"))]
  56 pub struct MmapMut(memmap2::MmapMut);
  57
  58 #[cfg(target_arch = "wasm32")]
  59 pub struct MmapMut(Vec<u8>);
  60
  61 #[cfg(not(target_arch = "wasm32"))]
  62 impl MmapMut {
  63     #[inline]
  64     pub fn map_anon(len: usize) -> io::Result<Self> {
  65         let mmap = memmap2::MmapMut::map_anon(len)?;
  66         Ok(MmapMut(mmap))
  67     }
  68
  69     #[inline]
  70     pub fn flush(&mut self) -> io::Result<()> {
  71         self.0.flush()
  72     }
  73
  74     #[inline]
  75     pub fn make_read_only(self) -> std::io::Result<Mmap> {
  76         let mmap = self.0.make_read_only()?;
  77         Ok(Mmap(mmap))
  78     }
  79 }
  80
  81 #[cfg(target_arch = "wasm32")]
  82 impl MmapMut {
  83     #[inline]
  84     pub fn map_anon(len: usize) -> io::Result<Self> {
  85         let data = Vec::with_capacity(len);
  86         Ok(MmapMut(data))
  87     }
  88
  89     #[inline]
  90     pub fn flush(&mut self) -> io::Result<()> {
  91         Ok(())
  92     }
  93
  94     #[inline]
  95     pub fn make_read_only(self) -> std::io::Result<Mmap> {
  96         Ok(Mmap(self.0))
  97     }
  98 }
  99
 100 impl Deref for MmapMut {
 101     type Target = [u8];
 102
 103     #[inline]
 104     fn deref(&self) -> &[u8] {
 105         &self.0
 106     }
 107 }
 108
 109 impl DerefMut for MmapMut {
 110     #[inline]
 111     fn deref_mut(&mut self) -> &mut [u8] {
 112         &mut self.0
 113     }
 114 }