]> git.lizzy.rs Git - rust.git/blob - compiler/rustc_query_impl/src/on_disk_cache.rs
Auto merge of #88698 - Noble-Mushtak:master, r=nikomatsakis,oli-obk
[rust.git] / compiler / rustc_query_impl / src / on_disk_cache.rs
1 use crate::QueryCtxt;
2 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
3 use rustc_data_structures::memmap::Mmap;
4 use rustc_data_structures::sync::{HashMapExt, Lock, Lrc, RwLock};
5 use rustc_data_structures::unhash::UnhashMap;
6 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, StableCrateId, LOCAL_CRATE};
7 use rustc_hir::definitions::DefPathHash;
8 use rustc_index::vec::{Idx, IndexVec};
9 use rustc_middle::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
10 use rustc_middle::mir::interpret::{AllocDecodingSession, AllocDecodingState};
11 use rustc_middle::mir::{self, interpret};
12 use rustc_middle::thir;
13 use rustc_middle::ty::codec::{RefDecodable, TyDecoder, TyEncoder};
14 use rustc_middle::ty::{self, Ty, TyCtxt};
15 use rustc_query_system::dep_graph::DepContext;
16 use rustc_query_system::query::{QueryContext, QuerySideEffects};
17 use rustc_serialize::{
18     opaque::{self, FileEncodeResult, FileEncoder, IntEncodedWithFixedSize},
19     Decodable, Decoder, Encodable, Encoder,
20 };
21 use rustc_session::Session;
22 use rustc_span::hygiene::{
23     ExpnId, HygieneDecodeContext, HygieneEncodeContext, SyntaxContext, SyntaxContextData,
24 };
25 use rustc_span::source_map::{SourceMap, StableSourceFileId};
26 use rustc_span::CachingSourceMapView;
27 use rustc_span::{BytePos, ExpnData, ExpnHash, Pos, SourceFile, Span};
28 use std::mem;
29
30 const TAG_FILE_FOOTER: u128 = 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
31
32 // A normal span encoded with both location information and a `SyntaxContext`
33 const TAG_FULL_SPAN: u8 = 0;
34 // A partial span with no location information, encoded only with a `SyntaxContext`
35 const TAG_PARTIAL_SPAN: u8 = 1;
36 const TAG_RELATIVE_SPAN: u8 = 2;
37
38 const TAG_SYNTAX_CONTEXT: u8 = 0;
39 const TAG_EXPN_DATA: u8 = 1;
40
41 /// Provides an interface to incremental compilation data cached from the
42 /// previous compilation session. This data will eventually include the results
43 /// of a few selected queries (like `typeck` and `mir_optimized`) and
44 /// any side effects that have been emitted during a query.
45 pub struct OnDiskCache<'sess> {
46     // The complete cache data in serialized form.
47     serialized_data: RwLock<Option<Mmap>>,
48
49     // Collects all `QuerySideEffects` created during the current compilation
50     // session.
51     current_side_effects: Lock<FxHashMap<DepNodeIndex, QuerySideEffects>>,
52
53     source_map: &'sess SourceMap,
54     file_index_to_stable_id: FxHashMap<SourceFileIndex, EncodedSourceFileId>,
55
56     // Caches that are populated lazily during decoding.
57     file_index_to_file: Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
58
59     // A map from dep-node to the position of the cached query result in
60     // `serialized_data`.
61     query_result_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
62
63     // A map from dep-node to the position of any associated `QuerySideEffects` in
64     // `serialized_data`.
65     prev_side_effects_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
66
67     alloc_decoding_state: AllocDecodingState,
68
69     // A map from syntax context ids to the position of their associated
70     // `SyntaxContextData`. We use a `u32` instead of a `SyntaxContext`
71     // to represent the fact that we are storing *encoded* ids. When we decode
72     // a `SyntaxContext`, a new id will be allocated from the global `HygieneData`,
73     // which will almost certainly be different than the serialized id.
74     syntax_contexts: FxHashMap<u32, AbsoluteBytePos>,
75     // A map from the `DefPathHash` of an `ExpnId` to the position
76     // of their associated `ExpnData`. Ideally, we would store a `DefId`,
77     // but we need to decode this before we've constructed a `TyCtxt` (which
78     // makes it difficult to decode a `DefId`).
79
80     // Note that these `DefPathHashes` correspond to both local and foreign
81     // `ExpnData` (e.g `ExpnData.krate` may not be `LOCAL_CRATE`). Alternatively,
82     // we could look up the `ExpnData` from the metadata of foreign crates,
83     // but it seemed easier to have `OnDiskCache` be independent of the `CStore`.
84     expn_data: UnhashMap<ExpnHash, AbsoluteBytePos>,
85     // Additional information used when decoding hygiene data.
86     hygiene_context: HygieneDecodeContext,
87     // Maps `ExpnHash`es to their raw value from the *previous*
88     // compilation session. This is used as an initial 'guess' when
89     // we try to map an `ExpnHash` to its value in the current
90     // compilation session.
91     foreign_expn_data: UnhashMap<ExpnHash, u32>,
92 }
93
94 // This type is used only for serialization and deserialization.
95 #[derive(Encodable, Decodable)]
96 struct Footer {
97     file_index_to_stable_id: FxHashMap<SourceFileIndex, EncodedSourceFileId>,
98     query_result_index: EncodedDepNodeIndex,
99     side_effects_index: EncodedDepNodeIndex,
100     // The location of all allocations.
101     interpret_alloc_index: Vec<u32>,
102     // See `OnDiskCache.syntax_contexts`
103     syntax_contexts: FxHashMap<u32, AbsoluteBytePos>,
104     // See `OnDiskCache.expn_data`
105     expn_data: UnhashMap<ExpnHash, AbsoluteBytePos>,
106     foreign_expn_data: UnhashMap<ExpnHash, u32>,
107 }
108
109 pub type EncodedDepNodeIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
110
111 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Encodable, Decodable)]
112 struct SourceFileIndex(u32);
113
114 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Encodable, Decodable)]
115 pub struct AbsoluteBytePos(u32);
116
117 impl AbsoluteBytePos {
118     fn new(pos: usize) -> AbsoluteBytePos {
119         debug_assert!(pos <= u32::MAX as usize);
120         AbsoluteBytePos(pos as u32)
121     }
122
123     fn to_usize(self) -> usize {
124         self.0 as usize
125     }
126 }
127
128 /// An `EncodedSourceFileId` is the same as a `StableSourceFileId` except that
129 /// the source crate is represented as a [StableCrateId] instead of as a
130 /// `CrateNum`. This way `EncodedSourceFileId` can be encoded and decoded
131 /// without any additional context, i.e. with a simple `opaque::Decoder` (which
132 /// is the only thing available when decoding the cache's [Footer].
133 #[derive(Encodable, Decodable, Clone, Debug)]
134 struct EncodedSourceFileId {
135     file_name_hash: u64,
136     stable_crate_id: StableCrateId,
137 }
138
139 impl EncodedSourceFileId {
140     fn translate(&self, tcx: TyCtxt<'_>) -> StableSourceFileId {
141         let cnum = tcx.stable_crate_id_to_crate_num(self.stable_crate_id);
142         StableSourceFileId { file_name_hash: self.file_name_hash, cnum }
143     }
144
145     fn new(tcx: TyCtxt<'_>, file: &SourceFile) -> EncodedSourceFileId {
146         let source_file_id = StableSourceFileId::new(file);
147         EncodedSourceFileId {
148             file_name_hash: source_file_id.file_name_hash,
149             stable_crate_id: tcx.stable_crate_id(source_file_id.cnum),
150         }
151     }
152 }
153
154 impl<'sess> rustc_middle::ty::OnDiskCache<'sess> for OnDiskCache<'sess> {
155     /// Creates a new `OnDiskCache` instance from the serialized data in `data`.
156     fn new(sess: &'sess Session, data: Mmap, start_pos: usize) -> Self {
157         debug_assert!(sess.opts.incremental.is_some());
158
159         // Wrap in a scope so we can borrow `data`.
160         let footer: Footer = {
161             let mut decoder = opaque::Decoder::new(&data[..], start_pos);
162
163             // Decode the *position* of the footer, which can be found in the
164             // last 8 bytes of the file.
165             decoder.set_position(data.len() - IntEncodedWithFixedSize::ENCODED_SIZE);
166             let footer_pos = IntEncodedWithFixedSize::decode(&mut decoder)
167                 .expect("error while trying to decode footer position")
168                 .0 as usize;
169
170             // Decode the file footer, which contains all the lookup tables, etc.
171             decoder.set_position(footer_pos);
172
173             decode_tagged(&mut decoder, TAG_FILE_FOOTER)
174                 .expect("error while trying to decode footer position")
175         };
176
177         Self {
178             serialized_data: RwLock::new(Some(data)),
179             file_index_to_stable_id: footer.file_index_to_stable_id,
180             file_index_to_file: Default::default(),
181             source_map: sess.source_map(),
182             current_side_effects: Default::default(),
183             query_result_index: footer.query_result_index.into_iter().collect(),
184             prev_side_effects_index: footer.side_effects_index.into_iter().collect(),
185             alloc_decoding_state: AllocDecodingState::new(footer.interpret_alloc_index),
186             syntax_contexts: footer.syntax_contexts,
187             expn_data: footer.expn_data,
188             foreign_expn_data: footer.foreign_expn_data,
189             hygiene_context: Default::default(),
190         }
191     }
192
193     fn new_empty(source_map: &'sess SourceMap) -> Self {
194         Self {
195             serialized_data: RwLock::new(None),
196             file_index_to_stable_id: Default::default(),
197             file_index_to_file: Default::default(),
198             source_map,
199             current_side_effects: Default::default(),
200             query_result_index: Default::default(),
201             prev_side_effects_index: Default::default(),
202             alloc_decoding_state: AllocDecodingState::new(Vec::new()),
203             syntax_contexts: FxHashMap::default(),
204             expn_data: UnhashMap::default(),
205             foreign_expn_data: UnhashMap::default(),
206             hygiene_context: Default::default(),
207         }
208     }
209
210     /// Execute all cache promotions and release the serialized backing Mmap.
211     ///
212     /// Cache promotions require invoking queries, which needs to read the serialized data.
213     /// In order to serialize the new on-disk cache, the former on-disk cache file needs to be
214     /// deleted, hence we won't be able to refer to its memmapped data.
215     fn drop_serialized_data(&self, tcx: TyCtxt<'tcx>) {
216         // Load everything into memory so we can write it out to the on-disk
217         // cache. The vast majority of cacheable query results should already
218         // be in memory, so this should be a cheap operation.
219         // Do this *before* we clone 'latest_foreign_def_path_hashes', since
220         // loading existing queries may cause us to create new DepNodes, which
221         // may in turn end up invoking `store_foreign_def_id_hash`
222         tcx.dep_graph.exec_cache_promotions(QueryCtxt::from_tcx(tcx));
223
224         *self.serialized_data.write() = None;
225     }
226
227     fn serialize<'tcx>(&self, tcx: TyCtxt<'tcx>, encoder: &mut FileEncoder) -> FileEncodeResult {
228         // Serializing the `DepGraph` should not modify it.
229         tcx.dep_graph.with_ignore(|| {
230             // Allocate `SourceFileIndex`es.
231             let (file_to_file_index, file_index_to_stable_id) = {
232                 let files = tcx.sess.source_map().files();
233                 let mut file_to_file_index =
234                     FxHashMap::with_capacity_and_hasher(files.len(), Default::default());
235                 let mut file_index_to_stable_id =
236                     FxHashMap::with_capacity_and_hasher(files.len(), Default::default());
237
238                 for (index, file) in files.iter().enumerate() {
239                     let index = SourceFileIndex(index as u32);
240                     let file_ptr: *const SourceFile = &**file as *const _;
241                     file_to_file_index.insert(file_ptr, index);
242                     let source_file_id = EncodedSourceFileId::new(tcx, &file);
243                     file_index_to_stable_id.insert(index, source_file_id);
244                 }
245
246                 (file_to_file_index, file_index_to_stable_id)
247             };
248
249             let hygiene_encode_context = HygieneEncodeContext::default();
250
251             let mut encoder = CacheEncoder {
252                 tcx,
253                 encoder,
254                 type_shorthands: Default::default(),
255                 predicate_shorthands: Default::default(),
256                 interpret_allocs: Default::default(),
257                 source_map: CachingSourceMapView::new(tcx.sess.source_map()),
258                 file_to_file_index,
259                 hygiene_context: &hygiene_encode_context,
260             };
261
262             // Encode query results.
263             let mut query_result_index = EncodedDepNodeIndex::new();
264
265             tcx.sess.time("encode_query_results", || -> FileEncodeResult {
266                 let enc = &mut encoder;
267                 let qri = &mut query_result_index;
268                 QueryCtxt::from_tcx(tcx).encode_query_results(enc, qri)
269             })?;
270
271             // Encode side effects.
272             let side_effects_index: EncodedDepNodeIndex = self
273                 .current_side_effects
274                 .borrow()
275                 .iter()
276                 .map(
277                     |(dep_node_index, side_effects)| -> Result<_, <FileEncoder as Encoder>::Error> {
278                         let pos = AbsoluteBytePos::new(encoder.position());
279                         let dep_node_index = SerializedDepNodeIndex::new(dep_node_index.index());
280                         encoder.encode_tagged(dep_node_index, side_effects)?;
281
282                         Ok((dep_node_index, pos))
283                     },
284                 )
285                 .collect::<Result<_, _>>()?;
286
287             let interpret_alloc_index = {
288                 let mut interpret_alloc_index = Vec::new();
289                 let mut n = 0;
290                 loop {
291                     let new_n = encoder.interpret_allocs.len();
292                     // If we have found new IDs, serialize those too.
293                     if n == new_n {
294                         // Otherwise, abort.
295                         break;
296                     }
297                     interpret_alloc_index.reserve(new_n - n);
298                     for idx in n..new_n {
299                         let id = encoder.interpret_allocs[idx];
300                         let pos = encoder.position() as u32;
301                         interpret_alloc_index.push(pos);
302                         interpret::specialized_encode_alloc_id(&mut encoder, tcx, id)?;
303                     }
304                     n = new_n;
305                 }
306                 interpret_alloc_index
307             };
308
309             let mut syntax_contexts = FxHashMap::default();
310             let mut expn_data = UnhashMap::default();
311             let mut foreign_expn_data = UnhashMap::default();
312
313             // Encode all hygiene data (`SyntaxContextData` and `ExpnData`) from the current
314             // session.
315
316             hygiene_encode_context.encode(
317                 &mut encoder,
318                 |encoder, index, ctxt_data| -> FileEncodeResult {
319                     let pos = AbsoluteBytePos::new(encoder.position());
320                     encoder.encode_tagged(TAG_SYNTAX_CONTEXT, ctxt_data)?;
321                     syntax_contexts.insert(index, pos);
322                     Ok(())
323                 },
324                 |encoder, expn_id, data, hash| -> FileEncodeResult {
325                     if expn_id.krate == LOCAL_CRATE {
326                         let pos = AbsoluteBytePos::new(encoder.position());
327                         encoder.encode_tagged(TAG_EXPN_DATA, data)?;
328                         expn_data.insert(hash, pos);
329                     } else {
330                         foreign_expn_data.insert(hash, expn_id.local_id.as_u32());
331                     }
332                     Ok(())
333                 },
334             )?;
335
336             // `Encode the file footer.
337             let footer_pos = encoder.position() as u64;
338             encoder.encode_tagged(
339                 TAG_FILE_FOOTER,
340                 &Footer {
341                     file_index_to_stable_id,
342                     query_result_index,
343                     side_effects_index,
344                     interpret_alloc_index,
345                     syntax_contexts,
346                     expn_data,
347                     foreign_expn_data,
348                 },
349             )?;
350
351             // Encode the position of the footer as the last 8 bytes of the
352             // file so we know where to look for it.
353             IntEncodedWithFixedSize(footer_pos).encode(encoder.encoder)?;
354
355             // DO NOT WRITE ANYTHING TO THE ENCODER AFTER THIS POINT! The address
356             // of the footer must be the last thing in the data stream.
357
358             Ok(())
359         })
360     }
361
362     fn def_path_hash_to_def_id(&self, tcx: TyCtxt<'tcx>, hash: DefPathHash) -> DefId {
363         debug!("def_path_hash_to_def_id({:?})", hash);
364
365         let stable_crate_id = hash.stable_crate_id();
366
367         // If this is a DefPathHash from the local crate, we can look up the
368         // DefId in the tcx's `Definitions`.
369         if stable_crate_id == tcx.sess.local_stable_crate_id() {
370             tcx.definitions_untracked().local_def_path_hash_to_def_id(hash).to_def_id()
371         } else {
372             // If this is a DefPathHash from an upstream crate, let the CrateStore map
373             // it to a DefId.
374             let cnum = tcx.cstore_untracked().stable_crate_id_to_crate_num(stable_crate_id);
375             tcx.cstore_untracked().def_path_hash_to_def_id(cnum, hash)
376         }
377     }
378 }
379
380 impl<'sess> OnDiskCache<'sess> {
381     pub fn as_dyn(&self) -> &dyn rustc_middle::ty::OnDiskCache<'sess> {
382         self as _
383     }
384
385     /// Loads a `QuerySideEffects` created during the previous compilation session.
386     pub fn load_side_effects(
387         &self,
388         tcx: TyCtxt<'_>,
389         dep_node_index: SerializedDepNodeIndex,
390     ) -> QuerySideEffects {
391         let side_effects: Option<QuerySideEffects> =
392             self.load_indexed(tcx, dep_node_index, &self.prev_side_effects_index, "side_effects");
393
394         side_effects.unwrap_or_default()
395     }
396
397     /// Stores a `QuerySideEffects` emitted during the current compilation session.
398     /// Anything stored like this will be available via `load_side_effects` in
399     /// the next compilation session.
400     #[inline(never)]
401     #[cold]
402     pub fn store_side_effects(&self, dep_node_index: DepNodeIndex, side_effects: QuerySideEffects) {
403         let mut current_side_effects = self.current_side_effects.borrow_mut();
404         let prev = current_side_effects.insert(dep_node_index, side_effects);
405         debug_assert!(prev.is_none());
406     }
407
408     /// Returns the cached query result if there is something in the cache for
409     /// the given `SerializedDepNodeIndex`; otherwise returns `None`.
410     pub fn try_load_query_result<'tcx, T>(
411         &self,
412         tcx: TyCtxt<'tcx>,
413         dep_node_index: SerializedDepNodeIndex,
414     ) -> Option<T>
415     where
416         T: for<'a> Decodable<CacheDecoder<'a, 'tcx>>,
417     {
418         self.load_indexed(tcx, dep_node_index, &self.query_result_index, "query result")
419     }
420
421     /// Stores side effect emitted during computation of an anonymous query.
422     /// Since many anonymous queries can share the same `DepNode`, we aggregate
423     /// them -- as opposed to regular queries where we assume that there is a
424     /// 1:1 relationship between query-key and `DepNode`.
425     #[inline(never)]
426     #[cold]
427     pub fn store_side_effects_for_anon_node(
428         &self,
429         dep_node_index: DepNodeIndex,
430         side_effects: QuerySideEffects,
431     ) {
432         let mut current_side_effects = self.current_side_effects.borrow_mut();
433
434         let x = current_side_effects.entry(dep_node_index).or_default();
435         x.append(side_effects);
436     }
437
438     fn load_indexed<'tcx, T>(
439         &self,
440         tcx: TyCtxt<'tcx>,
441         dep_node_index: SerializedDepNodeIndex,
442         index: &FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
443         debug_tag: &'static str,
444     ) -> Option<T>
445     where
446         T: for<'a> Decodable<CacheDecoder<'a, 'tcx>>,
447     {
448         let pos = index.get(&dep_node_index).cloned()?;
449
450         self.with_decoder(tcx, pos, |decoder| match decode_tagged(decoder, dep_node_index) {
451             Ok(v) => Some(v),
452             Err(e) => bug!("could not decode cached {}: {}", debug_tag, e),
453         })
454     }
455
456     fn with_decoder<'a, 'tcx, T, F: for<'s> FnOnce(&mut CacheDecoder<'s, 'tcx>) -> T>(
457         &'sess self,
458         tcx: TyCtxt<'tcx>,
459         pos: AbsoluteBytePos,
460         f: F,
461     ) -> T
462     where
463         T: Decodable<CacheDecoder<'a, 'tcx>>,
464     {
465         let serialized_data = self.serialized_data.read();
466         let mut decoder = CacheDecoder {
467             tcx,
468             opaque: opaque::Decoder::new(serialized_data.as_deref().unwrap_or(&[]), pos.to_usize()),
469             source_map: self.source_map,
470             file_index_to_file: &self.file_index_to_file,
471             file_index_to_stable_id: &self.file_index_to_stable_id,
472             alloc_decoding_session: self.alloc_decoding_state.new_decoding_session(),
473             syntax_contexts: &self.syntax_contexts,
474             expn_data: &self.expn_data,
475             foreign_expn_data: &self.foreign_expn_data,
476             hygiene_context: &self.hygiene_context,
477         };
478         f(&mut decoder)
479     }
480 }
481
482 //- DECODING -------------------------------------------------------------------
483
484 /// A decoder that can read from the incremental compilation cache. It is similar to the one
485 /// we use for crate metadata decoding in that it can rebase spans and eventually
486 /// will also handle things that contain `Ty` instances.
487 pub struct CacheDecoder<'a, 'tcx> {
488     tcx: TyCtxt<'tcx>,
489     opaque: opaque::Decoder<'a>,
490     source_map: &'a SourceMap,
491     file_index_to_file: &'a Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
492     file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, EncodedSourceFileId>,
493     alloc_decoding_session: AllocDecodingSession<'a>,
494     syntax_contexts: &'a FxHashMap<u32, AbsoluteBytePos>,
495     expn_data: &'a UnhashMap<ExpnHash, AbsoluteBytePos>,
496     foreign_expn_data: &'a UnhashMap<ExpnHash, u32>,
497     hygiene_context: &'a HygieneDecodeContext,
498 }
499
500 impl<'a, 'tcx> CacheDecoder<'a, 'tcx> {
501     fn file_index_to_file(&self, index: SourceFileIndex) -> Lrc<SourceFile> {
502         let CacheDecoder {
503             tcx,
504             ref file_index_to_file,
505             ref file_index_to_stable_id,
506             ref source_map,
507             ..
508         } = *self;
509
510         file_index_to_file
511             .borrow_mut()
512             .entry(index)
513             .or_insert_with(|| {
514                 let stable_id = file_index_to_stable_id[&index].translate(tcx);
515                 source_map
516                     .source_file_by_stable_id(stable_id)
517                     .expect("failed to lookup `SourceFile` in new context")
518             })
519             .clone()
520     }
521 }
522
523 trait DecoderWithPosition: Decoder {
524     fn position(&self) -> usize;
525 }
526
527 impl<'a> DecoderWithPosition for opaque::Decoder<'a> {
528     fn position(&self) -> usize {
529         self.position()
530     }
531 }
532
533 impl<'a, 'tcx> DecoderWithPosition for CacheDecoder<'a, 'tcx> {
534     fn position(&self) -> usize {
535         self.opaque.position()
536     }
537 }
538
539 // Decodes something that was encoded with `encode_tagged()` and verify that the
540 // tag matches and the correct amount of bytes was read.
541 fn decode_tagged<D, T, V>(decoder: &mut D, expected_tag: T) -> Result<V, D::Error>
542 where
543     T: Decodable<D> + Eq + std::fmt::Debug,
544     V: Decodable<D>,
545     D: DecoderWithPosition,
546 {
547     let start_pos = decoder.position();
548
549     let actual_tag = T::decode(decoder)?;
550     assert_eq!(actual_tag, expected_tag);
551     let value = V::decode(decoder)?;
552     let end_pos = decoder.position();
553
554     let expected_len: u64 = Decodable::decode(decoder)?;
555     assert_eq!((end_pos - start_pos) as u64, expected_len);
556
557     Ok(value)
558 }
559
560 impl<'a, 'tcx> TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> {
561     const CLEAR_CROSS_CRATE: bool = false;
562
563     #[inline]
564     fn tcx(&self) -> TyCtxt<'tcx> {
565         self.tcx
566     }
567
568     #[inline]
569     fn position(&self) -> usize {
570         self.opaque.position()
571     }
572
573     #[inline]
574     fn peek_byte(&self) -> u8 {
575         self.opaque.data[self.opaque.position()]
576     }
577
578     fn cached_ty_for_shorthand<F>(
579         &mut self,
580         shorthand: usize,
581         or_insert_with: F,
582     ) -> Result<Ty<'tcx>, Self::Error>
583     where
584         F: FnOnce(&mut Self) -> Result<Ty<'tcx>, Self::Error>,
585     {
586         let tcx = self.tcx();
587
588         let cache_key = ty::CReaderCacheKey { cnum: None, pos: shorthand };
589
590         if let Some(&ty) = tcx.ty_rcache.borrow().get(&cache_key) {
591             return Ok(ty);
592         }
593
594         let ty = or_insert_with(self)?;
595         // This may overwrite the entry, but it should overwrite with the same value.
596         tcx.ty_rcache.borrow_mut().insert_same(cache_key, ty);
597         Ok(ty)
598     }
599
600     fn with_position<F, R>(&mut self, pos: usize, f: F) -> R
601     where
602         F: FnOnce(&mut Self) -> R,
603     {
604         debug_assert!(pos < self.opaque.data.len());
605
606         let new_opaque = opaque::Decoder::new(self.opaque.data, pos);
607         let old_opaque = mem::replace(&mut self.opaque, new_opaque);
608         let r = f(self);
609         self.opaque = old_opaque;
610         r
611     }
612
613     fn decode_alloc_id(&mut self) -> Result<interpret::AllocId, Self::Error> {
614         let alloc_decoding_session = self.alloc_decoding_session;
615         alloc_decoding_session.decode_alloc_id(self)
616     }
617 }
618
619 rustc_middle::implement_ty_decoder!(CacheDecoder<'a, 'tcx>);
620
621 // This ensures that the `Decodable<opaque::Decoder>::decode` specialization for `Vec<u8>` is used
622 // when a `CacheDecoder` is passed to `Decodable::decode`. Unfortunately, we have to manually opt
623 // into specializations this way, given how `CacheDecoder` and the decoding traits currently work.
624 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for Vec<u8> {
625     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
626         Decodable::decode(&mut d.opaque)
627     }
628 }
629
630 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for SyntaxContext {
631     fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
632         let syntax_contexts = decoder.syntax_contexts;
633         rustc_span::hygiene::decode_syntax_context(decoder, decoder.hygiene_context, |this, id| {
634             // This closure is invoked if we haven't already decoded the data for the `SyntaxContext` we are deserializing.
635             // We look up the position of the associated `SyntaxData` and decode it.
636             let pos = syntax_contexts.get(&id).unwrap();
637             this.with_position(pos.to_usize(), |decoder| {
638                 let data: SyntaxContextData = decode_tagged(decoder, TAG_SYNTAX_CONTEXT)?;
639                 Ok(data)
640             })
641         })
642     }
643 }
644
645 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for ExpnId {
646     fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
647         let hash = ExpnHash::decode(decoder)?;
648         if hash.is_root() {
649             return Ok(ExpnId::root());
650         }
651
652         if let Some(expn_id) = ExpnId::from_hash(hash) {
653             return Ok(expn_id);
654         }
655
656         let krate = decoder.tcx.stable_crate_id_to_crate_num(hash.stable_crate_id());
657
658         let expn_id = if krate == LOCAL_CRATE {
659             // We look up the position of the associated `ExpnData` and decode it.
660             let pos = decoder
661                 .expn_data
662                 .get(&hash)
663                 .unwrap_or_else(|| panic!("Bad hash {:?} (map {:?})", hash, decoder.expn_data));
664
665             let data: ExpnData = decoder
666                 .with_position(pos.to_usize(), |decoder| decode_tagged(decoder, TAG_EXPN_DATA))?;
667             let expn_id = rustc_span::hygiene::register_local_expn_id(data, hash);
668
669             #[cfg(debug_assertions)]
670             {
671                 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
672                 let mut hcx = decoder.tcx.create_stable_hashing_context();
673                 let mut hasher = StableHasher::new();
674                 hcx.while_hashing_spans(true, |hcx| {
675                     expn_id.expn_data().hash_stable(hcx, &mut hasher)
676                 });
677                 let local_hash: u64 = hasher.finish();
678                 debug_assert_eq!(hash.local_hash(), local_hash);
679             }
680
681             expn_id
682         } else {
683             let index_guess = decoder.foreign_expn_data[&hash];
684             decoder.tcx.cstore_untracked().expn_hash_to_expn_id(
685                 decoder.tcx.sess,
686                 krate,
687                 index_guess,
688                 hash,
689             )
690         };
691
692         debug_assert_eq!(expn_id.krate, krate);
693         Ok(expn_id)
694     }
695 }
696
697 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for Span {
698     fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
699         let ctxt = SyntaxContext::decode(decoder)?;
700         let parent = Option::<LocalDefId>::decode(decoder)?;
701         let tag: u8 = Decodable::decode(decoder)?;
702
703         if tag == TAG_PARTIAL_SPAN {
704             return Ok(Span::new(BytePos(0), BytePos(0), ctxt, parent));
705         } else if tag == TAG_RELATIVE_SPAN {
706             let dlo = u32::decode(decoder)?;
707             let dto = u32::decode(decoder)?;
708
709             let enclosing =
710                 decoder.tcx.definitions_untracked().def_span(parent.unwrap()).data_untracked();
711             let span = Span::new(
712                 enclosing.lo + BytePos::from_u32(dlo),
713                 enclosing.lo + BytePos::from_u32(dto),
714                 ctxt,
715                 parent,
716             );
717
718             return Ok(span);
719         } else {
720             debug_assert_eq!(tag, TAG_FULL_SPAN);
721         }
722
723         let file_lo_index = SourceFileIndex::decode(decoder)?;
724         let line_lo = usize::decode(decoder)?;
725         let col_lo = BytePos::decode(decoder)?;
726         let len = BytePos::decode(decoder)?;
727
728         let file_lo = decoder.file_index_to_file(file_lo_index);
729         let lo = file_lo.lines[line_lo - 1] + col_lo;
730         let hi = lo + len;
731
732         Ok(Span::new(lo, hi, ctxt, parent))
733     }
734 }
735
736 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for CrateNum {
737     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
738         let stable_id = StableCrateId::decode(d)?;
739         let cnum = d.tcx.stable_crate_id_to_crate_num(stable_id);
740         Ok(cnum)
741     }
742 }
743
744 // This impl makes sure that we get a runtime error when we try decode a
745 // `DefIndex` that is not contained in a `DefId`. Such a case would be problematic
746 // because we would not know how to transform the `DefIndex` to the current
747 // context.
748 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for DefIndex {
749     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<DefIndex, String> {
750         Err(d.error("trying to decode `DefIndex` outside the context of a `DefId`"))
751     }
752 }
753
754 // Both the `CrateNum` and the `DefIndex` of a `DefId` can change in between two
755 // compilation sessions. We use the `DefPathHash`, which is stable across
756 // sessions, to map the old `DefId` to the new one.
757 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for DefId {
758     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
759         // Load the `DefPathHash` which is was we encoded the `DefId` as.
760         let def_path_hash = DefPathHash::decode(d)?;
761
762         // Using the `DefPathHash`, we can lookup the new `DefId`.
763         // Subtle: We only encode a `DefId` as part of a query result.
764         // If we get to this point, then all of the query inputs were green,
765         // which means that the definition with this hash is guaranteed to
766         // still exist in the current compilation session.
767         Ok(d.tcx().on_disk_cache.as_ref().unwrap().def_path_hash_to_def_id(d.tcx(), def_path_hash))
768     }
769 }
770
771 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx FxHashSet<LocalDefId> {
772     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
773         RefDecodable::decode(d)
774     }
775 }
776
777 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>>
778     for &'tcx IndexVec<mir::Promoted, mir::Body<'tcx>>
779 {
780     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
781         RefDecodable::decode(d)
782     }
783 }
784
785 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [thir::abstract_const::Node<'tcx>] {
786     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
787         RefDecodable::decode(d)
788     }
789 }
790
791 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [(ty::Predicate<'tcx>, Span)] {
792     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
793         RefDecodable::decode(d)
794     }
795 }
796
797 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [rustc_ast::InlineAsmTemplatePiece] {
798     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
799         RefDecodable::decode(d)
800     }
801 }
802
803 impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [Span] {
804     fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> {
805         RefDecodable::decode(d)
806     }
807 }
808
809 //- ENCODING -------------------------------------------------------------------
810
811 pub trait OpaqueEncoder: Encoder {
812     fn position(&self) -> usize;
813 }
814
815 impl OpaqueEncoder for FileEncoder {
816     #[inline]
817     fn position(&self) -> usize {
818         FileEncoder::position(self)
819     }
820 }
821
822 /// An encoder that can write to the incremental compilation cache.
823 pub struct CacheEncoder<'a, 'tcx, E: OpaqueEncoder> {
824     tcx: TyCtxt<'tcx>,
825     encoder: &'a mut E,
826     type_shorthands: FxHashMap<Ty<'tcx>, usize>,
827     predicate_shorthands: FxHashMap<ty::PredicateKind<'tcx>, usize>,
828     interpret_allocs: FxIndexSet<interpret::AllocId>,
829     source_map: CachingSourceMapView<'tcx>,
830     file_to_file_index: FxHashMap<*const SourceFile, SourceFileIndex>,
831     hygiene_context: &'a HygieneEncodeContext,
832 }
833
834 impl<'a, 'tcx, E> CacheEncoder<'a, 'tcx, E>
835 where
836     E: 'a + OpaqueEncoder,
837 {
838     fn source_file_index(&mut self, source_file: Lrc<SourceFile>) -> SourceFileIndex {
839         self.file_to_file_index[&(&*source_file as *const SourceFile)]
840     }
841
842     /// Encode something with additional information that allows to do some
843     /// sanity checks when decoding the data again. This method will first
844     /// encode the specified tag, then the given value, then the number of
845     /// bytes taken up by tag and value. On decoding, we can then verify that
846     /// we get the expected tag and read the expected number of bytes.
847     fn encode_tagged<T: Encodable<Self>, V: Encodable<Self>>(
848         &mut self,
849         tag: T,
850         value: &V,
851     ) -> Result<(), E::Error> {
852         let start_pos = self.position();
853
854         tag.encode(self)?;
855         value.encode(self)?;
856
857         let end_pos = self.position();
858         ((end_pos - start_pos) as u64).encode(self)
859     }
860 }
861
862 impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for SyntaxContext
863 where
864     E: 'a + OpaqueEncoder,
865 {
866     fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> {
867         rustc_span::hygiene::raw_encode_syntax_context(*self, s.hygiene_context, s)
868     }
869 }
870
871 impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for ExpnId
872 where
873     E: 'a + OpaqueEncoder,
874 {
875     fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> {
876         s.hygiene_context.schedule_expn_data_for_encoding(*self);
877         self.expn_hash().encode(s)
878     }
879 }
880
881 impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for Span
882 where
883     E: 'a + OpaqueEncoder,
884 {
885     fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> {
886         let span_data = self.data_untracked();
887         span_data.ctxt.encode(s)?;
888         span_data.parent.encode(s)?;
889
890         if span_data.is_dummy() {
891             return TAG_PARTIAL_SPAN.encode(s);
892         }
893
894         if let Some(parent) = span_data.parent {
895             let enclosing = s.tcx.definitions_untracked().def_span(parent).data_untracked();
896             if enclosing.contains(span_data) {
897                 TAG_RELATIVE_SPAN.encode(s)?;
898                 (span_data.lo - enclosing.lo).to_u32().encode(s)?;
899                 (span_data.hi - enclosing.lo).to_u32().encode(s)?;
900                 return Ok(());
901             }
902         }
903
904         let pos = s.source_map.byte_pos_to_line_and_col(span_data.lo);
905         let partial_span = match &pos {
906             Some((file_lo, _, _)) => !file_lo.contains(span_data.hi),
907             None => true,
908         };
909
910         if partial_span {
911             return TAG_PARTIAL_SPAN.encode(s);
912         }
913
914         let (file_lo, line_lo, col_lo) = pos.unwrap();
915
916         let len = span_data.hi - span_data.lo;
917
918         let source_file_index = s.source_file_index(file_lo);
919
920         TAG_FULL_SPAN.encode(s)?;
921         source_file_index.encode(s)?;
922         line_lo.encode(s)?;
923         col_lo.encode(s)?;
924         len.encode(s)
925     }
926 }
927
928 impl<'a, 'tcx, E> TyEncoder<'tcx> for CacheEncoder<'a, 'tcx, E>
929 where
930     E: 'a + OpaqueEncoder,
931 {
932     const CLEAR_CROSS_CRATE: bool = false;
933
934     fn position(&self) -> usize {
935         self.encoder.position()
936     }
937     fn type_shorthands(&mut self) -> &mut FxHashMap<Ty<'tcx>, usize> {
938         &mut self.type_shorthands
939     }
940     fn predicate_shorthands(&mut self) -> &mut FxHashMap<ty::PredicateKind<'tcx>, usize> {
941         &mut self.predicate_shorthands
942     }
943     fn encode_alloc_id(&mut self, alloc_id: &interpret::AllocId) -> Result<(), Self::Error> {
944         let (index, _) = self.interpret_allocs.insert_full(*alloc_id);
945
946         index.encode(self)
947     }
948 }
949
950 impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for CrateNum
951 where
952     E: 'a + OpaqueEncoder,
953 {
954     fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> {
955         s.tcx.stable_crate_id(*self).encode(s)
956     }
957 }
958
959 impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for DefId
960 where
961     E: 'a + OpaqueEncoder,
962 {
963     fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> {
964         s.tcx.def_path_hash(*self).encode(s)
965     }
966 }
967
968 impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for DefIndex
969 where
970     E: 'a + OpaqueEncoder,
971 {
972     fn encode(&self, _: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> {
973         bug!("encoding `DefIndex` without context");
974     }
975 }
976
977 macro_rules! encoder_methods {
978     ($($name:ident($ty:ty);)*) => {
979         #[inline]
980         $(fn $name(&mut self, value: $ty) -> Result<(), Self::Error> {
981             self.encoder.$name(value)
982         })*
983     }
984 }
985
986 impl<'a, 'tcx, E> Encoder for CacheEncoder<'a, 'tcx, E>
987 where
988     E: 'a + OpaqueEncoder,
989 {
990     type Error = E::Error;
991
992     #[inline]
993     fn emit_unit(&mut self) -> Result<(), Self::Error> {
994         Ok(())
995     }
996
997     encoder_methods! {
998         emit_usize(usize);
999         emit_u128(u128);
1000         emit_u64(u64);
1001         emit_u32(u32);
1002         emit_u16(u16);
1003         emit_u8(u8);
1004
1005         emit_isize(isize);
1006         emit_i128(i128);
1007         emit_i64(i64);
1008         emit_i32(i32);
1009         emit_i16(i16);
1010         emit_i8(i8);
1011
1012         emit_bool(bool);
1013         emit_f64(f64);
1014         emit_f32(f32);
1015         emit_char(char);
1016         emit_str(&str);
1017         emit_raw_bytes(&[u8]);
1018     }
1019 }
1020
1021 // This ensures that the `Encodable<opaque::FileEncoder>::encode` specialization for byte slices
1022 // is used when a `CacheEncoder` having an `opaque::FileEncoder` is passed to `Encodable::encode`.
1023 // Unfortunately, we have to manually opt into specializations this way, given how `CacheEncoder`
1024 // and the encoding traits currently work.
1025 impl<'a, 'tcx> Encodable<CacheEncoder<'a, 'tcx, FileEncoder>> for [u8] {
1026     fn encode(&self, e: &mut CacheEncoder<'a, 'tcx, FileEncoder>) -> FileEncodeResult {
1027         self.encode(e.encoder)
1028     }
1029 }
1030
1031 pub fn encode_query_results<'a, 'tcx, CTX, Q>(
1032     tcx: CTX,
1033     encoder: &mut CacheEncoder<'a, 'tcx, FileEncoder>,
1034     query_result_index: &mut EncodedDepNodeIndex,
1035 ) -> FileEncodeResult
1036 where
1037     CTX: QueryContext + 'tcx,
1038     Q: super::QueryDescription<CTX> + super::QueryAccessors<CTX>,
1039     Q::Value: Encodable<CacheEncoder<'a, 'tcx, FileEncoder>>,
1040 {
1041     let _timer = tcx
1042         .dep_context()
1043         .profiler()
1044         .extra_verbose_generic_activity("encode_query_results_for", std::any::type_name::<Q>());
1045
1046     assert!(Q::query_state(tcx).all_inactive());
1047     let cache = Q::query_cache(tcx);
1048     let mut res = Ok(());
1049     cache.iter_results(&mut |key, value, dep_node| {
1050         if res.is_err() {
1051             return;
1052         }
1053         if Q::cache_on_disk(tcx, &key, Some(value)) {
1054             let dep_node = SerializedDepNodeIndex::new(dep_node.index());
1055
1056             // Record position of the cache entry.
1057             query_result_index.push((dep_node, AbsoluteBytePos::new(encoder.encoder.position())));
1058
1059             // Encode the type check tables with the `SerializedDepNodeIndex`
1060             // as tag.
1061             match encoder.encode_tagged(dep_node, value) {
1062                 Ok(()) => {}
1063                 Err(e) => {
1064                     res = Err(e);
1065                 }
1066             }
1067         }
1068     });
1069
1070     res
1071 }