rustc_metadata: generalize Table<T> to hold T, not Lazy<T>, elements.

Author: eddyb

src/librustc_metadata/decoder.rs

@@ -2,7 +2,7 @@
 
 use crate::cstore::{self, CrateMetadata, MetadataBlob, NativeLibrary, ForeignModule};
 use crate::schema::*;
-use crate::table::PerDefTable;
+use crate::table::{FixedSizeEncoding, PerDefTable};
 
 use rustc_data_structures::sync::{Lrc, ReadGuard};
 use rustc::hir::map::{DefKey, DefPath, DefPathData, DefPathHash, Definitions};
@@ -255,7 +255,7 @@ impl<'a, 'tcx, T: Encodable> SpecializedDecoder<Lazy<[T]>> for DecodeContext<'a,
 }
 
 impl<'a, 'tcx, T> SpecializedDecoder<Lazy<PerDefTable<T>>> for DecodeContext<'a, 'tcx>
-    where T: LazyMeta<Meta = ()>,
+    where Option<T>: FixedSizeEncoding,
 {
     fn specialized_decode(&mut self) -> Result<Lazy<PerDefTable<T>>, Self::Error> {
         let lo_hi = [
@@ -498,7 +498,7 @@ impl<'a, 'tcx> CrateMetadata {
 
     fn maybe_entry(&self, item_id: DefIndex) -> Option<Lazy<Entry<'tcx>>> {
         assert!(!self.is_proc_macro(item_id));
-        self.root.per_def.entry.lookup(self.blob.raw_bytes(), item_id)
+        self.root.per_def.entry.get(self.blob.raw_bytes(), item_id)
     }
 
     fn entry(&self, item_id: DefIndex) -> Entry<'tcx> {

src/librustc_metadata/encoder.rs

@@ -1,5 +1,5 @@
 use crate::schema::*;
-use crate::table::PerDefTable;
+use crate::table::{FixedSizeEncoding, PerDefTable};
 
 use rustc::middle::cstore::{LinkagePreference, NativeLibrary,
                             EncodedMetadata, ForeignModule};
@@ -59,7 +59,7 @@ pub struct EncodeContext<'a, 'tcx: 'a> {
 }
 
 struct PerDefTables<'tcx> {
-    entry: PerDefTable<Entry<'tcx>>,
+    entry: PerDefTable<Lazy<Entry<'tcx>>>,
 }
 
 macro_rules! encoder_methods {
@@ -117,7 +117,7 @@ impl<'a, 'tcx, T: Encodable> SpecializedEncoder<Lazy<[T]>> for EncodeContext<'a,
 }
 
 impl<'a, 'tcx, T> SpecializedEncoder<Lazy<PerDefTable<T>>> for EncodeContext<'a, 'tcx>
-    where T: LazyMeta<Meta = ()>,
+    where Option<T>: FixedSizeEncoding,
 {
     fn specialized_encode(&mut self, lazy: &Lazy<PerDefTable<T>>) -> Result<(), Self::Error> {
         self.emit_usize(lazy.meta[0])?;
@@ -273,14 +273,14 @@ impl<I, T: Encodable> EncodeContentsForLazy<[T]> for I
     }
 }
 
-// Shorthand for `$self.$tables.$table.record($key, $self.lazy($value))`, which would
+// Shorthand for `$self.$tables.$table.set($key, $self.lazy($value))`, which would
 // normally need extra variables to avoid errors about multiple mutable borrows.
 macro_rules! record {
     ($self:ident.$tables:ident[$key:expr]: $($table:ident => $value:expr,)+) => {{
         $({
             let value = $value;
             let lazy = $self.lazy(value);
-            $self.$tables.$table.record($key, lazy);
+            $self.$tables.$table.set($key, lazy);
         })+
     }}
 }

src/librustc_metadata/schema.rs

@@ -220,7 +220,7 @@ pub struct TraitImpls {
 
 #[derive(RustcEncodable, RustcDecodable)]
 pub struct LazyPerDefTables<'tcx> {
-    pub entry: Lazy!(PerDefTable<Entry<'tcx>>),
+    pub entry: Lazy!(PerDefTable<Lazy<Entry<'tcx>>>),
 }
 
 #[derive(RustcEncodable, RustcDecodable)]

src/librustc_metadata/table.rs

@@ -6,39 +6,98 @@ use std::marker::PhantomData;
 use std::num::NonZeroUsize;
 use log::debug;
 
-/// Random-access position table, allowing encoding in an arbitrary order
-/// (e.g. while visiting the definitions of a crate), and on-demand decoding
-/// of specific indices (e.g. queries for per-definition data).
-/// Similar to `Vec<Lazy<T>>`, but with zero-copy decoding.
-// FIXME(eddyb) newtype `[u8]` here, such that `Box<Table<T>>` would be used
+/// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
+/// Used mainly for Lazy positions and lengths.
+/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+/// but this has no impact on safety.
+pub trait FixedSizeEncoding: Default {
+    const BYTE_LEN: usize;
+
+    // FIXME(eddyb) convert to and from `[u8; Self::BYTE_LEN]` instead,
+    // once that starts being allowed by the compiler (i.e. lazy normalization).
+    fn from_bytes(b: &[u8]) -> Self;
+    fn write_to_bytes(self, b: &mut [u8]);
+}
+
+impl FixedSizeEncoding for u32 {
+    const BYTE_LEN: usize = 4;
+
+    fn from_bytes(b: &[u8]) -> Self {
+        let mut bytes = [0; Self::BYTE_LEN];
+        bytes.copy_from_slice(&b[..Self::BYTE_LEN]);
+        Self::from_le_bytes(bytes)
+    }
+
+    fn write_to_bytes(self, b: &mut [u8]) {
+        b[..Self::BYTE_LEN].copy_from_slice(&self.to_le_bytes());
+    }
+}
+
+// NOTE(eddyb) there could be an impl for `usize`, which would enable a more
+// generic `Lazy<T>` impl, but in the general case we might not need / want to
+// fit every `usize` in `u32`.
+impl<T: Encodable> FixedSizeEncoding for Option<Lazy<T>> {
+    const BYTE_LEN: usize = u32::BYTE_LEN;
+
+    fn from_bytes(b: &[u8]) -> Self {
+        Some(Lazy::from_position(NonZeroUsize::new(u32::from_bytes(b) as usize)?))
+    }
+
+    fn write_to_bytes(self, b: &mut [u8]) {
+        let position = self.map_or(0, |lazy| lazy.position.get());
+        let position_u32 = position as u32;
+        assert_eq!(position_u32 as usize, position);
+
+        position_u32.write_to_bytes(b)
+    }
+}
+
+impl<T: Encodable> FixedSizeEncoding for Option<Lazy<[T]>> {
+    const BYTE_LEN: usize = u32::BYTE_LEN * 2;
+
+    fn from_bytes(b: &[u8]) -> Self {
+        Some(Lazy::from_position_and_meta(
+            <Option<Lazy<T>>>::from_bytes(b)?.position,
+            u32::from_bytes(&b[u32::BYTE_LEN..]) as usize,
+        ))
+    }
+
+    fn write_to_bytes(self, b: &mut [u8]) {
+        self.map(|lazy| Lazy::<T>::from_position(lazy.position))
+            .write_to_bytes(b);
+
+        let len = self.map_or(0, |lazy| lazy.meta);
+        let len_u32 = len as u32;
+        assert_eq!(len_u32 as usize, len);
+
+        len_u32.write_to_bytes(&mut b[u32::BYTE_LEN..]);
+    }
+}
+
+/// Random-access table, similar to `Vec<Option<T>>`, but without requiring
+/// encoding or decoding all the values eagerly and in-order.
+// FIXME(eddyb) replace `Vec` with `[_]` here, such that `Box<Table<T>>` would be used
 // when building it, and `Lazy<Table<T>>` or `&Table<T>` when reading it.
 // Sadly, that doesn't work for `DefPerTable`, which is `(Table<T>, Table<T>)`,
 // and so would need two lengths in its metadata, which is not supported yet.
-pub struct Table<T: LazyMeta<Meta = ()>> {
+pub struct Table<T> where Option<T>: FixedSizeEncoding {
+    // FIXME(eddyb) store `[u8; <Option<T>>::BYTE_LEN]` instead of `u8` in `Vec`,
+    // once that starts being allowed by the compiler (i.e. lazy normalization).
     bytes: Vec<u8>,
     _marker: PhantomData<T>,
 }
 
-impl<T: LazyMeta<Meta = ()>> Table<T> {
+impl<T> Table<T> where Option<T>: FixedSizeEncoding {
     pub fn new(len: usize) -> Self {
         Table {
-            bytes: vec![0; len * 4],
+            // FIXME(eddyb) only allocate and encode as many entries as needed.
+            bytes: vec![0; len * <Option<T>>::BYTE_LEN],
             _marker: PhantomData,
         }
     }
 
-    pub fn record(&mut self, i: usize, entry: Lazy<T>) {
-        let position = entry.position.get() as u32;
-        assert_eq!(position as usize, entry.position.get());
-
-        let bytes = &mut self.bytes[i * 4..];
-        assert!(read_le_u32(bytes) == 0,
-                "recorded position for index {:?} twice, first at {:?} and now at {:?}",
-                i,
-                read_le_u32(bytes),
-                position);
-
-        write_le_u32(bytes, position);
+    pub fn set(&mut self, i: usize, value: T) {
+        Some(value).write_to_bytes(&mut self.bytes[i * <Option<T>>::BYTE_LEN..]);
     }
 
     pub fn encode(&self, buf: &mut Encoder) -> Lazy<Self> {
@@ -51,58 +110,45 @@ impl<T: LazyMeta<Meta = ()>> Table<T> {
     }
 }
 
-impl<T: LazyMeta<Meta = ()>> LazyMeta for Table<T> {
+impl<T> LazyMeta for Table<T> where Option<T>: FixedSizeEncoding {
     type Meta = usize;
 
     fn min_size(len: usize) -> usize {
         len
     }
 }
 
-impl<T: Encodable> Lazy<Table<T>> {
-    /// Given the metadata, extract out the offset of a particular index (if any).
+impl<T> Lazy<Table<T>> where Option<T>: FixedSizeEncoding {
+    /// Given the metadata, extract out the value at a particular index (if any).
     #[inline(never)]
-    pub fn lookup(&self, bytes: &[u8], i: usize) -> Option<Lazy<T>> {
+    pub fn get(&self, bytes: &[u8], i: usize) -> Option<T> {
         debug!("Table::lookup: index={:?} len={:?}", i, self.meta);
 
         let bytes = &bytes[self.position.get()..][..self.meta];
-        let position = read_le_u32(&bytes[i * 4..]);
-        debug!("Table::lookup: position={:?}", position);
-
-        NonZeroUsize::new(position as usize).map(Lazy::from_position)
+        <Option<T>>::from_bytes(&bytes[i * <Option<T>>::BYTE_LEN..])
     }
 }
 
-fn read_le_u32(b: &[u8]) -> u32 {
-    let mut bytes = [0; 4];
-    bytes.copy_from_slice(&b[..4]);
-    u32::from_le_bytes(bytes)
-}
-
-fn write_le_u32(b: &mut [u8], x: u32) {
-    b[..4].copy_from_slice(&x.to_le_bytes());
-}
-
 /// Per-definition table, similar to `Table` but keyed on `DefIndex`.
 /// Needed because of the two `DefIndexAddressSpace`s a `DefIndex` can be in.
-pub struct PerDefTable<T: LazyMeta<Meta = ()>> {
+pub struct PerDefTable<T> where Option<T>: FixedSizeEncoding {
     lo: Table<T>,
     hi: Table<T>,
 }
 
-impl<T: LazyMeta<Meta = ()>> PerDefTable<T> {
+impl<T> PerDefTable<T> where Option<T>: FixedSizeEncoding {
     pub fn new((max_index_lo, max_index_hi): (usize, usize)) -> Self {
         PerDefTable {
             lo: Table::new(max_index_lo),
             hi: Table::new(max_index_hi),
         }
     }
 
-    pub fn record(&mut self, def_id: DefId, entry: Lazy<T>) {
+    pub fn set(&mut self, def_id: DefId, value: T) {
         assert!(def_id.is_local());
         let space_index = def_id.index.address_space().index();
         let array_index = def_id.index.as_array_index();
-        [&mut self.lo, &mut self.hi][space_index].record(array_index, entry);
+        [&mut self.lo, &mut self.hi][space_index].set(array_index, value);
     }
 
     pub fn encode(&self, buf: &mut Encoder) -> Lazy<Self> {
@@ -117,15 +163,15 @@ impl<T: LazyMeta<Meta = ()>> PerDefTable<T> {
     }
 }
 
-impl<T: LazyMeta<Meta = ()>> LazyMeta for PerDefTable<T> {
+impl<T> LazyMeta for PerDefTable<T> where Option<T>: FixedSizeEncoding {
     type Meta = [<Table<T> as LazyMeta>::Meta; 2];
 
     fn min_size([lo, hi]: Self::Meta) -> usize {
         Table::<T>::min_size(lo) + Table::<T>::min_size(hi)
     }
 }
 
-impl<T: Encodable> Lazy<PerDefTable<T>> {
+impl<T> Lazy<PerDefTable<T>> where Option<T>: FixedSizeEncoding {
     fn table_for_space(&self, space: DefIndexAddressSpace) -> Lazy<Table<T>> {
         let space_index = space.index();
         let offset = space_index.checked_sub(1).map_or(0, |i| self.meta[i]);
@@ -135,11 +181,10 @@ impl<T: Encodable> Lazy<PerDefTable<T>> {
         )
     }
 
-    /// Given the metadata, extract out the offset of a particular DefIndex (if any).
+    /// Given the metadata, extract out the value at a particular DefIndex (if any).
     #[inline(never)]
-    pub fn lookup(&self, bytes: &[u8], def_index: DefIndex) -> Option<Lazy<T>> {
+    pub fn get(&self, bytes: &[u8], def_index: DefIndex) -> Option<T> {
         self.table_for_space(def_index.address_space())
-            .lookup(bytes, def_index.as_array_index())
+            .get(bytes, def_index.as_array_index())
     }
 }
-