rustc_metadata: don't use more space than needed, for each Table.

Author: eddyb

src/librustc_metadata/encoder.rs

@@ -58,6 +58,7 @@ pub struct EncodeContext<'a, 'tcx: 'a> {
     source_file_cache: Lrc<SourceFile>,
 }
 
+#[derive(Default)]
 struct PerDefTables<'tcx> {
     kind: PerDefTable<Lazy<EntryKind<'tcx>>>,
     visibility: PerDefTable<Lazy<ty::Visibility>>,
@@ -1830,28 +1831,10 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
     // Since encoding metadata is not in a query, and nothing is cached,
     // there's no need to do dep-graph tracking for any of it.
     let (root, mut result) = tcx.dep_graph.with_ignore(move || {
-        let def_counts = tcx.hir().definitions().def_index_counts_lo_hi();
         let mut ecx = EncodeContext {
             opaque: encoder,
             tcx,
-            per_def: PerDefTables {
-                kind: PerDefTable::new(def_counts),
-                visibility: PerDefTable::new(def_counts),
-                span: PerDefTable::new(def_counts),
-                attributes: PerDefTable::new(def_counts),
-                children: PerDefTable::new(def_counts),
-                stability: PerDefTable::new(def_counts),
-                deprecation: PerDefTable::new(def_counts),
-
-                ty: PerDefTable::new(def_counts),
-                inherent_impls: PerDefTable::new(def_counts),
-                variances: PerDefTable::new(def_counts),
-                generics: PerDefTable::new(def_counts),
-                predicates: PerDefTable::new(def_counts),
-                predicates_defined_on: PerDefTable::new(def_counts),
-
-                mir: PerDefTable::new(def_counts),
-            },
+            per_def: Default::default(),
             lazy_state: LazyState::NoNode,
             type_shorthands: Default::default(),
             predicate_shorthands: Default::default(),

src/librustc_metadata/table.rs

@@ -22,15 +22,15 @@ pub trait FixedSizeEncoding: Default {
     // FIXME(eddyb) make these generic functions, or at least defaults here.
     // (same problem as above, needs `[u8; Self::BYTE_LEN]`)
     // For now, a macro (`fixed_size_encoding_byte_len_and_defaults`) is used.
-    fn read_from_bytes_at(b: &[u8], i: usize) -> Self;
+    fn maybe_read_from_bytes_at(b: &[u8], i: usize) -> Option<Self>;
     fn write_to_bytes_at(self, b: &mut [u8], i: usize);
 }
 
 // HACK(eddyb) this shouldn't be needed (see comments on the methods above).
 macro_rules! fixed_size_encoding_byte_len_and_defaults {
     ($byte_len:expr) => {
         const BYTE_LEN: usize = $byte_len;
-        fn read_from_bytes_at(b: &[u8], i: usize) -> Self {
+        fn maybe_read_from_bytes_at(b: &[u8], i: usize) -> Option<Self> {
             const BYTE_LEN: usize = $byte_len;
             // HACK(eddyb) ideally this would be done with fully safe code,
             // but slicing `[u8]` with `i * N..` is optimized worse, due to the
@@ -41,7 +41,7 @@ macro_rules! fixed_size_encoding_byte_len_and_defaults {
                     b.len() / BYTE_LEN,
                 )
             };
-            FixedSizeEncoding::from_bytes(&b[i])
+            b.get(i).map(|b| FixedSizeEncoding::from_bytes(b))
         }
         fn write_to_bytes_at(self, b: &mut [u8], i: usize) {
             const BYTE_LEN: usize = $byte_len;
@@ -126,16 +126,21 @@ pub struct Table<T> where Option<T>: FixedSizeEncoding {
     _marker: PhantomData<T>,
 }
 
-impl<T> Table<T> where Option<T>: FixedSizeEncoding {
-    pub fn new(len: usize) -> Self {
+impl<T> Default for Table<T> where Option<T>: FixedSizeEncoding {
+    fn default() -> Self {
         Table {
-            // FIXME(eddyb) only allocate and encode as many entries as needed.
-            bytes: vec![0; len * <Option<T>>::BYTE_LEN],
+            bytes: vec![],
             _marker: PhantomData,
         }
     }
+}
 
+impl<T> Table<T> where Option<T>: FixedSizeEncoding {
     pub fn set(&mut self, i: usize, value: T) {
+        let needed = (i + 1) * <Option<T>>::BYTE_LEN;
+        if self.bytes.len() < needed {
+            self.bytes.resize(needed, 0);
+        }
         Some(value).write_to_bytes_at(&mut self.bytes, i);
     }
 
@@ -168,7 +173,7 @@ impl<T> Lazy<Table<T>> where Option<T>: FixedSizeEncoding {
         debug!("Table::lookup: index={:?} len={:?}", i, self.meta);
 
         let bytes = &metadata.raw_bytes()[self.position.get()..][..self.meta];
-        <Option<T>>::read_from_bytes_at(bytes, i)
+        <Option<T>>::maybe_read_from_bytes_at(bytes, i)?
     }
 }
 
@@ -179,14 +184,16 @@ pub struct PerDefTable<T> where Option<T>: FixedSizeEncoding {
     hi: Table<T>,
 }
 
-impl<T> PerDefTable<T> where Option<T>: FixedSizeEncoding {
-    pub fn new((max_index_lo, max_index_hi): (usize, usize)) -> Self {
+impl<T> Default for PerDefTable<T> where Option<T>: FixedSizeEncoding {
+    fn default() -> Self {
         PerDefTable {
-            lo: Table::new(max_index_lo),
-            hi: Table::new(max_index_hi),
+            lo: Table::default(),
+            hi: Table::default(),
         }
     }
+}
 
+impl<T> PerDefTable<T> where Option<T>: FixedSizeEncoding {
     pub fn set(&mut self, def_id: DefId, value: T) {
         assert!(def_id.is_local());
         let space_index = def_id.index.address_space().index();