1 use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
3 use crate::hir::def_id::{CrateNum, DefIndex, DefId, LocalDefId, LOCAL_CRATE};
4 use crate::hir::map::definitions::DefPathHash;
5 use crate::ich::{CachingSourceMapView, Fingerprint};
6 use crate::mir::{self, interpret};
7 use crate::mir::interpret::{AllocDecodingSession, AllocDecodingState};
8 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque,
9 SpecializedDecoder, SpecializedEncoder,
10 UseSpecializedDecodable, UseSpecializedEncodable};
11 use crate::session::{CrateDisambiguator, Session};
12 use crate::ty::{self, Ty};
13 use crate::ty::codec::{self as ty_codec, TyDecoder, TyEncoder};
14 use crate::ty::context::TyCtxt;
15 use crate::util::common::{time, time_ext};
17 use errors::Diagnostic;
18 use rustc_data_structures::fx::FxHashMap;
19 use rustc_data_structures::thin_vec::ThinVec;
20 use rustc_data_structures::sync::{Lrc, Lock, HashMapExt, Once};
21 use rustc_data_structures::indexed_vec::{IndexVec, Idx};
23 use syntax::ast::NodeId;
24 use syntax::source_map::{SourceMap, StableSourceFileId};
25 use syntax_pos::{BytePos, Span, DUMMY_SP, SourceFile};
26 use syntax_pos::hygiene::{ExpnId, SyntaxContext, ExpnInfo};
28 const TAG_FILE_FOOTER: u128 = 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
30 const TAG_CLEAR_CROSS_CRATE_CLEAR: u8 = 0;
31 const TAG_CLEAR_CROSS_CRATE_SET: u8 = 1;
33 const TAG_NO_EXPANSION_INFO: u8 = 0;
34 const TAG_EXPANSION_INFO_SHORTHAND: u8 = 1;
35 const TAG_EXPANSION_INFO_INLINE: u8 = 2;
37 const TAG_VALID_SPAN: u8 = 0;
38 const TAG_INVALID_SPAN: u8 = 1;
40 /// `OnDiskCache` provides an interface to incr. comp. data cached from the
41 /// previous compilation session. This data will eventually include the results
42 /// of a few selected queries (like `typeck_tables_of` and `mir_optimized`) and
43 /// any diagnostics that have been emitted during a query.
44 pub struct OnDiskCache<'sess> {
46 // The complete cache data in serialized form.
47 serialized_data: Vec<u8>,
49 // This field collects all Diagnostics emitted during the current
50 // compilation session.
51 current_diagnostics: Lock<FxHashMap<DepNodeIndex, Vec<Diagnostic>>>,
53 prev_cnums: Vec<(u32, String, CrateDisambiguator)>,
54 cnum_map: Once<IndexVec<CrateNum, Option<CrateNum>>>,
56 source_map: &'sess SourceMap,
57 file_index_to_stable_id: FxHashMap<SourceFileIndex, StableSourceFileId>,
59 // These two fields caches that are populated lazily during decoding.
60 file_index_to_file: Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
61 synthetic_expansion_infos: Lock<FxHashMap<AbsoluteBytePos, SyntaxContext>>,
63 // A map from dep-node to the position of the cached query result in
65 query_result_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
67 // A map from dep-node to the position of any associated diagnostics in
69 prev_diagnostics_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
71 alloc_decoding_state: AllocDecodingState,
74 // This type is used only for (de-)serialization.
75 #[derive(RustcEncodable, RustcDecodable)]
77 file_index_to_stable_id: FxHashMap<SourceFileIndex, StableSourceFileId>,
78 prev_cnums: Vec<(u32, String, CrateDisambiguator)>,
79 query_result_index: EncodedQueryResultIndex,
80 diagnostics_index: EncodedQueryResultIndex,
81 // the location of all allocations
82 interpret_alloc_index: Vec<u32>,
85 type EncodedQueryResultIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
86 type EncodedDiagnosticsIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
87 type EncodedDiagnostics = Vec<Diagnostic>;
89 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
90 struct SourceFileIndex(u32);
92 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, RustcEncodable, RustcDecodable)]
93 struct AbsoluteBytePos(u32);
95 impl AbsoluteBytePos {
96 fn new(pos: usize) -> AbsoluteBytePos {
97 debug_assert!(pos <= ::std::u32::MAX as usize);
98 AbsoluteBytePos(pos as u32)
101 fn to_usize(self) -> usize {
106 impl<'sess> OnDiskCache<'sess> {
107 /// Creates a new OnDiskCache instance from the serialized data in `data`.
108 pub fn new(sess: &'sess Session, data: Vec<u8>, start_pos: usize) -> OnDiskCache<'sess> {
109 debug_assert!(sess.opts.incremental.is_some());
111 // Wrapping in a scope so we can borrow `data`
112 let footer: Footer = {
113 let mut decoder = opaque::Decoder::new(&data[..], start_pos);
115 // Decode the *position* of the footer which can be found in the
116 // last 8 bytes of the file.
117 decoder.set_position(data.len() - IntEncodedWithFixedSize::ENCODED_SIZE);
118 let query_result_index_pos = IntEncodedWithFixedSize::decode(&mut decoder)
119 .expect("Error while trying to decode query result index position.")
122 // Decoder the file footer which contains all the lookup tables, etc.
123 decoder.set_position(query_result_index_pos);
124 decode_tagged(&mut decoder, TAG_FILE_FOOTER)
125 .expect("Error while trying to decode query result index position.")
129 serialized_data: data,
130 file_index_to_stable_id: footer.file_index_to_stable_id,
131 file_index_to_file: Default::default(),
132 prev_cnums: footer.prev_cnums,
133 cnum_map: Once::new(),
134 source_map: sess.source_map(),
135 current_diagnostics: Default::default(),
136 query_result_index: footer.query_result_index.into_iter().collect(),
137 prev_diagnostics_index: footer.diagnostics_index.into_iter().collect(),
138 synthetic_expansion_infos: Default::default(),
139 alloc_decoding_state: AllocDecodingState::new(footer.interpret_alloc_index),
143 pub fn new_empty(source_map: &'sess SourceMap) -> OnDiskCache<'sess> {
145 serialized_data: Vec::new(),
146 file_index_to_stable_id: Default::default(),
147 file_index_to_file: Default::default(),
149 cnum_map: Once::new(),
151 current_diagnostics: Default::default(),
152 query_result_index: Default::default(),
153 prev_diagnostics_index: Default::default(),
154 synthetic_expansion_infos: Default::default(),
155 alloc_decoding_state: AllocDecodingState::new(Vec::new()),
159 pub fn serialize<'tcx, E>(&self, tcx: TyCtxt<'tcx>, encoder: &mut E) -> Result<(), E::Error>
161 E: ty_codec::TyEncoder,
163 // Serializing the DepGraph should not modify it:
164 tcx.dep_graph.with_ignore(|| {
165 // Allocate SourceFileIndices
166 let (file_to_file_index, file_index_to_stable_id) = {
167 let files = tcx.sess.source_map().files();
168 let mut file_to_file_index = FxHashMap::with_capacity_and_hasher(
169 files.len(), Default::default());
170 let mut file_index_to_stable_id = FxHashMap::with_capacity_and_hasher(
171 files.len(), Default::default());
173 for (index, file) in files.iter().enumerate() {
174 let index = SourceFileIndex(index as u32);
175 let file_ptr: *const SourceFile = &**file as *const _;
176 file_to_file_index.insert(file_ptr, index);
177 file_index_to_stable_id.insert(index, StableSourceFileId::new(&file));
180 (file_to_file_index, file_index_to_stable_id)
183 let mut encoder = CacheEncoder {
186 type_shorthands: Default::default(),
187 predicate_shorthands: Default::default(),
188 expn_info_shorthands: Default::default(),
189 interpret_allocs: Default::default(),
190 interpret_allocs_inverse: Vec::new(),
191 source_map: CachingSourceMapView::new(tcx.sess.source_map()),
195 // Load everything into memory so we can write it out to the on-disk
196 // cache. The vast majority of cacheable query results should already
197 // be in memory, so this should be a cheap operation.
198 tcx.dep_graph.exec_cache_promotions(tcx);
200 // Encode query results
201 let mut query_result_index = EncodedQueryResultIndex::new();
203 time(tcx.sess, "encode query results", || {
204 let enc = &mut encoder;
205 let qri = &mut query_result_index;
207 macro_rules! encode_queries {
208 ($($query:ident,)*) => {
210 encode_query_results::<ty::query::queries::$query<'_>, _>(
219 rustc_cached_queries!(encode_queries!);
224 // Encode diagnostics
225 let diagnostics_index: EncodedDiagnosticsIndex = self.current_diagnostics.borrow()
227 .map(|(dep_node_index, diagnostics)|
229 let pos = AbsoluteBytePos::new(encoder.position());
230 // Let's make sure we get the expected type here:
231 let diagnostics: &EncodedDiagnostics = diagnostics;
232 let dep_node_index = SerializedDepNodeIndex::new(dep_node_index.index());
233 encoder.encode_tagged(dep_node_index, diagnostics)?;
235 Ok((dep_node_index, pos))
237 .collect::<Result<_, _>>()?;
239 let interpret_alloc_index = {
240 let mut interpret_alloc_index = Vec::new();
243 let new_n = encoder.interpret_allocs_inverse.len();
244 // if we have found new ids, serialize those, too
249 interpret_alloc_index.reserve(new_n - n);
250 for idx in n..new_n {
251 let id = encoder.interpret_allocs_inverse[idx];
252 let pos = encoder.position() as u32;
253 interpret_alloc_index.push(pos);
254 interpret::specialized_encode_alloc_id(
262 interpret_alloc_index
265 let sorted_cnums = sorted_cnums_including_local_crate(tcx);
266 let prev_cnums: Vec<_> = sorted_cnums.iter().map(|&cnum| {
267 let crate_name = tcx.original_crate_name(cnum).as_str().to_string();
268 let crate_disambiguator = tcx.crate_disambiguator(cnum);
269 (cnum.as_u32(), crate_name, crate_disambiguator)
272 // Encode the file footer
273 let footer_pos = encoder.position() as u64;
274 encoder.encode_tagged(TAG_FILE_FOOTER, &Footer {
275 file_index_to_stable_id,
279 interpret_alloc_index,
282 // Encode the position of the footer as the last 8 bytes of the
283 // file so we know where to look for it.
284 IntEncodedWithFixedSize(footer_pos).encode(encoder.encoder)?;
286 // DO NOT WRITE ANYTHING TO THE ENCODER AFTER THIS POINT! The address
287 // of the footer must be the last thing in the data stream.
291 fn sorted_cnums_including_local_crate(tcx: TyCtxt<'_>) -> Vec<CrateNum> {
292 let mut cnums = vec![LOCAL_CRATE];
293 cnums.extend_from_slice(&tcx.crates()[..]);
294 cnums.sort_unstable();
295 // Just to be sure...
302 /// Loads a diagnostic emitted during the previous compilation session.
303 pub fn load_diagnostics(
306 dep_node_index: SerializedDepNodeIndex,
307 ) -> Vec<Diagnostic> {
308 let diagnostics: Option<EncodedDiagnostics> = self.load_indexed(
311 &self.prev_diagnostics_index,
314 diagnostics.unwrap_or_default()
317 /// Stores a diagnostic emitted during the current compilation session.
318 /// Anything stored like this will be available via `load_diagnostics` in
319 /// the next compilation session.
322 pub fn store_diagnostics(&self,
323 dep_node_index: DepNodeIndex,
324 diagnostics: ThinVec<Diagnostic>) {
325 let mut current_diagnostics = self.current_diagnostics.borrow_mut();
326 let prev = current_diagnostics.insert(dep_node_index, diagnostics.into());
327 debug_assert!(prev.is_none());
330 /// Returns the cached query result if there is something in the cache for
331 /// the given `SerializedDepNodeIndex`; otherwise returns `None`.
332 pub fn try_load_query_result<T>(
335 dep_node_index: SerializedDepNodeIndex,
340 self.load_indexed(tcx,
342 &self.query_result_index,
346 /// Stores a diagnostic emitted during computation of an anonymous query.
347 /// Since many anonymous queries can share the same `DepNode`, we aggregate
348 /// them -- as opposed to regular queries where we assume that there is a
349 /// 1:1 relationship between query-key and `DepNode`.
352 pub fn store_diagnostics_for_anon_node(&self,
353 dep_node_index: DepNodeIndex,
354 diagnostics: ThinVec<Diagnostic>) {
355 let mut current_diagnostics = self.current_diagnostics.borrow_mut();
357 let x = current_diagnostics.entry(dep_node_index).or_insert(Vec::new());
359 x.extend(Into::<Vec<_>>::into(diagnostics));
362 fn load_indexed<'tcx, T>(
365 dep_node_index: SerializedDepNodeIndex,
366 index: &FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
367 debug_tag: &'static str,
372 let pos = index.get(&dep_node_index).cloned()?;
374 // Initialize the cnum_map using the value from the thread which finishes the closure first
375 self.cnum_map.init_nonlocking_same(|| {
376 Self::compute_cnum_map(tcx, &self.prev_cnums[..])
379 let mut decoder = CacheDecoder {
381 opaque: opaque::Decoder::new(&self.serialized_data[..], pos.to_usize()),
382 source_map: self.source_map,
383 cnum_map: self.cnum_map.get(),
384 file_index_to_file: &self.file_index_to_file,
385 file_index_to_stable_id: &self.file_index_to_stable_id,
386 synthetic_expansion_infos: &self.synthetic_expansion_infos,
387 alloc_decoding_session: self.alloc_decoding_state.new_decoding_session(),
390 match decode_tagged(&mut decoder, dep_node_index) {
395 bug!("Could not decode cached {}: {}", debug_tag, e)
400 // This function builds mapping from previous-session-CrateNum to
401 // current-session-CrateNum. There might be CrateNums from the previous
402 // Session that don't occur in the current one. For these, the mapping
406 prev_cnums: &[(u32, String, CrateDisambiguator)],
407 ) -> IndexVec<CrateNum, Option<CrateNum>> {
408 tcx.dep_graph.with_ignore(|| {
409 let current_cnums = tcx.all_crate_nums(LOCAL_CRATE).iter().map(|&cnum| {
410 let crate_name = tcx.original_crate_name(cnum)
412 let crate_disambiguator = tcx.crate_disambiguator(cnum);
413 ((crate_name, crate_disambiguator), cnum)
414 }).collect::<FxHashMap<_,_>>();
416 let map_size = prev_cnums.iter()
417 .map(|&(cnum, ..)| cnum)
420 let mut map = IndexVec::from_elem_n(None, map_size as usize);
422 for &(prev_cnum, ref crate_name, crate_disambiguator) in prev_cnums {
423 let key = (crate_name.clone(), crate_disambiguator);
424 map[CrateNum::from_u32(prev_cnum)] = current_cnums.get(&key).cloned();
427 map[LOCAL_CRATE] = Some(LOCAL_CRATE);
433 //- DECODING -------------------------------------------------------------------
435 /// A decoder that can read the incr. comp. cache. It is similar to the one
436 /// we use for crate metadata decoding in that it can rebase spans and
437 /// eventually will also handle things that contain `Ty` instances.
438 struct CacheDecoder<'a, 'tcx> {
440 opaque: opaque::Decoder<'a>,
441 source_map: &'a SourceMap,
442 cnum_map: &'a IndexVec<CrateNum, Option<CrateNum>>,
443 synthetic_expansion_infos: &'a Lock<FxHashMap<AbsoluteBytePos, SyntaxContext>>,
444 file_index_to_file: &'a Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
445 file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, StableSourceFileId>,
446 alloc_decoding_session: AllocDecodingSession<'a>,
449 impl<'a, 'tcx> CacheDecoder<'a, 'tcx> {
450 fn file_index_to_file(&self, index: SourceFileIndex) -> Lrc<SourceFile> {
452 ref file_index_to_file,
453 ref file_index_to_stable_id,
458 file_index_to_file.borrow_mut().entry(index).or_insert_with(|| {
459 let stable_id = file_index_to_stable_id[&index];
460 source_map.source_file_by_stable_id(stable_id)
461 .expect("Failed to lookup SourceFile in new context.")
466 trait DecoderWithPosition: Decoder {
467 fn position(&self) -> usize;
470 impl<'a> DecoderWithPosition for opaque::Decoder<'a> {
471 fn position(&self) -> usize {
476 impl<'a, 'tcx> DecoderWithPosition for CacheDecoder<'a, 'tcx> {
477 fn position(&self) -> usize {
478 self.opaque.position()
482 // Decode something that was encoded with encode_tagged() and verify that the
483 // tag matches and the correct amount of bytes was read.
484 fn decode_tagged<D, T, V>(decoder: &mut D, expected_tag: T) -> Result<V, D::Error>
486 T: Decodable + Eq + ::std::fmt::Debug,
488 D: DecoderWithPosition,
490 let start_pos = decoder.position();
492 let actual_tag = T::decode(decoder)?;
493 assert_eq!(actual_tag, expected_tag);
494 let value = V::decode(decoder)?;
495 let end_pos = decoder.position();
497 let expected_len: u64 = Decodable::decode(decoder)?;
498 assert_eq!((end_pos - start_pos) as u64, expected_len);
503 impl<'a, 'tcx> ty_codec::TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> {
505 fn tcx(&self) -> TyCtxt<'tcx> {
510 fn position(&self) -> usize {
511 self.opaque.position()
515 fn peek_byte(&self) -> u8 {
516 self.opaque.data[self.opaque.position()]
519 fn cached_ty_for_shorthand<F>(&mut self,
522 -> Result<Ty<'tcx>, Self::Error>
523 where F: FnOnce(&mut Self) -> Result<Ty<'tcx>, Self::Error>
525 let tcx = self.tcx();
527 let cache_key = ty::CReaderCacheKey {
528 cnum: CrateNum::ReservedForIncrCompCache,
532 if let Some(&ty) = tcx.rcache.borrow().get(&cache_key) {
536 let ty = or_insert_with(self)?;
537 // This may overwrite the entry, but it should overwrite with the same value
538 tcx.rcache.borrow_mut().insert_same(cache_key, ty);
542 fn with_position<F, R>(&mut self, pos: usize, f: F) -> R
543 where F: FnOnce(&mut Self) -> R
545 debug_assert!(pos < self.opaque.data.len());
547 let new_opaque = opaque::Decoder::new(self.opaque.data, pos);
548 let old_opaque = mem::replace(&mut self.opaque, new_opaque);
550 self.opaque = old_opaque;
554 fn map_encoded_cnum_to_current(&self, cnum: CrateNum) -> CrateNum {
555 self.cnum_map[cnum].unwrap_or_else(|| {
556 bug!("Could not find new CrateNum for {:?}", cnum)
561 implement_ty_decoder!(CacheDecoder<'a, 'tcx>);
563 impl<'a, 'tcx> SpecializedDecoder<interpret::AllocId> for CacheDecoder<'a, 'tcx> {
564 fn specialized_decode(&mut self) -> Result<interpret::AllocId, Self::Error> {
565 let alloc_decoding_session = self.alloc_decoding_session;
566 alloc_decoding_session.decode_alloc_id(self)
570 impl<'a, 'tcx> SpecializedDecoder<Span> for CacheDecoder<'a, 'tcx> {
571 fn specialized_decode(&mut self) -> Result<Span, Self::Error> {
572 let tag: u8 = Decodable::decode(self)?;
574 if tag == TAG_INVALID_SPAN {
577 debug_assert_eq!(tag, TAG_VALID_SPAN);
580 let file_lo_index = SourceFileIndex::decode(self)?;
581 let line_lo = usize::decode(self)?;
582 let col_lo = BytePos::decode(self)?;
583 let len = BytePos::decode(self)?;
585 let file_lo = self.file_index_to_file(file_lo_index);
586 let lo = file_lo.lines[line_lo - 1] + col_lo;
589 let expn_info_tag = u8::decode(self)?;
591 // FIXME(mw): This method does not restore `InternalExpnData::parent` or
592 // `SyntaxContextData::prev_ctxt` or `SyntaxContextData::opaque`. These things
593 // don't seem to be used after HIR lowering, so everything should be fine
594 // as long as incremental compilation does not kick in before that.
595 let location = || Span::new(lo, hi, SyntaxContext::empty());
596 let recover_from_expn_info = |this: &Self, expn_info, pos| {
597 let span = location().fresh_expansion(ExpnId::root(), expn_info);
598 this.synthetic_expansion_infos.borrow_mut().insert(pos, span.ctxt());
601 Ok(match expn_info_tag {
602 TAG_NO_EXPANSION_INFO => {
605 TAG_EXPANSION_INFO_INLINE => {
606 let expn_info = Decodable::decode(self)?;
607 recover_from_expn_info(
608 self, expn_info, AbsoluteBytePos::new(self.opaque.position())
611 TAG_EXPANSION_INFO_SHORTHAND => {
612 let pos = AbsoluteBytePos::decode(self)?;
613 let cached_ctxt = self.synthetic_expansion_infos.borrow().get(&pos).cloned();
614 if let Some(ctxt) = cached_ctxt {
615 Span::new(lo, hi, ctxt)
618 self.with_position(pos.to_usize(), |this| ExpnInfo::decode(this))?;
619 recover_from_expn_info(self, expn_info, pos)
629 // This impl makes sure that we get a runtime error when we try decode a
630 // DefIndex that is not contained in a DefId. Such a case would be problematic
631 // because we would not know how to transform the DefIndex to the current
633 impl<'a, 'tcx> SpecializedDecoder<DefIndex> for CacheDecoder<'a, 'tcx> {
634 fn specialized_decode(&mut self) -> Result<DefIndex, Self::Error> {
635 bug!("Trying to decode DefIndex outside the context of a DefId")
639 // Both the CrateNum and the DefIndex of a DefId can change in between two
640 // compilation sessions. We use the DefPathHash, which is stable across
641 // sessions, to map the old DefId to the new one.
642 impl<'a, 'tcx> SpecializedDecoder<DefId> for CacheDecoder<'a, 'tcx> {
644 fn specialized_decode(&mut self) -> Result<DefId, Self::Error> {
645 // Load the DefPathHash which is was we encoded the DefId as.
646 let def_path_hash = DefPathHash::decode(self)?;
648 // Using the DefPathHash, we can lookup the new DefId
649 Ok(self.tcx().def_path_hash_to_def_id.as_ref().unwrap()[&def_path_hash])
653 impl<'a, 'tcx> SpecializedDecoder<LocalDefId> for CacheDecoder<'a, 'tcx> {
655 fn specialized_decode(&mut self) -> Result<LocalDefId, Self::Error> {
656 Ok(LocalDefId::from_def_id(DefId::decode(self)?))
660 impl<'a, 'tcx> SpecializedDecoder<hir::HirId> for CacheDecoder<'a, 'tcx> {
661 fn specialized_decode(&mut self) -> Result<hir::HirId, Self::Error> {
662 // Load the DefPathHash which is was we encoded the DefIndex as.
663 let def_path_hash = DefPathHash::decode(self)?;
665 // Use the DefPathHash to map to the current DefId.
666 let def_id = self.tcx()
667 .def_path_hash_to_def_id
669 .unwrap()[&def_path_hash];
671 debug_assert!(def_id.is_local());
673 // The ItemLocalId needs no remapping.
674 let local_id = hir::ItemLocalId::decode(self)?;
676 // Reconstruct the HirId and look up the corresponding NodeId in the
677 // context of the current session.
685 // NodeIds are not stable across compilation sessions, so we store them in their
686 // HirId representation. This allows use to map them to the current NodeId.
687 impl<'a, 'tcx> SpecializedDecoder<NodeId> for CacheDecoder<'a, 'tcx> {
689 fn specialized_decode(&mut self) -> Result<NodeId, Self::Error> {
690 let hir_id = hir::HirId::decode(self)?;
691 Ok(self.tcx().hir().hir_to_node_id(hir_id))
695 impl<'a, 'tcx> SpecializedDecoder<Fingerprint> for CacheDecoder<'a, 'tcx> {
696 fn specialized_decode(&mut self) -> Result<Fingerprint, Self::Error> {
697 Fingerprint::decode_opaque(&mut self.opaque)
701 impl<'a, 'tcx, T: Decodable> SpecializedDecoder<mir::ClearCrossCrate<T>>
702 for CacheDecoder<'a, 'tcx>
705 fn specialized_decode(&mut self) -> Result<mir::ClearCrossCrate<T>, Self::Error> {
706 let discr = u8::decode(self)?;
709 TAG_CLEAR_CROSS_CRATE_CLEAR => Ok(mir::ClearCrossCrate::Clear),
710 TAG_CLEAR_CROSS_CRATE_SET => {
711 let val = T::decode(self)?;
712 Ok(mir::ClearCrossCrate::Set(val))
721 //- ENCODING -------------------------------------------------------------------
723 struct CacheEncoder<'a, 'tcx, E: ty_codec::TyEncoder> {
726 type_shorthands: FxHashMap<Ty<'tcx>, usize>,
727 predicate_shorthands: FxHashMap<ty::Predicate<'tcx>, usize>,
728 expn_info_shorthands: FxHashMap<ExpnId, AbsoluteBytePos>,
729 interpret_allocs: FxHashMap<interpret::AllocId, usize>,
730 interpret_allocs_inverse: Vec<interpret::AllocId>,
731 source_map: CachingSourceMapView<'tcx>,
732 file_to_file_index: FxHashMap<*const SourceFile, SourceFileIndex>,
735 impl<'a, 'tcx, E> CacheEncoder<'a, 'tcx, E>
737 E: 'a + ty_codec::TyEncoder,
739 fn source_file_index(&mut self, source_file: Lrc<SourceFile>) -> SourceFileIndex {
740 self.file_to_file_index[&(&*source_file as *const SourceFile)]
743 /// Encode something with additional information that allows to do some
744 /// sanity checks when decoding the data again. This method will first
745 /// encode the specified tag, then the given value, then the number of
746 /// bytes taken up by tag and value. On decoding, we can then verify that
747 /// we get the expected tag and read the expected number of bytes.
748 fn encode_tagged<T: Encodable, V: Encodable>(&mut self,
751 -> Result<(), E::Error>
753 let start_pos = self.position();
758 let end_pos = self.position();
759 ((end_pos - start_pos) as u64).encode(self)
763 impl<'a, 'tcx, E> SpecializedEncoder<interpret::AllocId> for CacheEncoder<'a, 'tcx, E>
765 E: 'a + ty_codec::TyEncoder,
767 fn specialized_encode(&mut self, alloc_id: &interpret::AllocId) -> Result<(), Self::Error> {
768 use std::collections::hash_map::Entry;
769 let index = match self.interpret_allocs.entry(*alloc_id) {
770 Entry::Occupied(e) => *e.get(),
771 Entry::Vacant(e) => {
772 let idx = self.interpret_allocs_inverse.len();
773 self.interpret_allocs_inverse.push(*alloc_id);
783 impl<'a, 'tcx, E> SpecializedEncoder<Span> for CacheEncoder<'a, 'tcx, E>
785 E: 'a + ty_codec::TyEncoder,
787 fn specialized_encode(&mut self, span: &Span) -> Result<(), Self::Error> {
789 if *span == DUMMY_SP {
790 return TAG_INVALID_SPAN.encode(self);
793 let span_data = span.data();
795 if span_data.hi < span_data.lo {
796 return TAG_INVALID_SPAN.encode(self);
799 let (file_lo, line_lo, col_lo) = match self.source_map
800 .byte_pos_to_line_and_col(span_data.lo) {
802 None => return TAG_INVALID_SPAN.encode(self)
805 if !file_lo.contains(span_data.hi) {
806 return TAG_INVALID_SPAN.encode(self);
809 let len = span_data.hi - span_data.lo;
811 let source_file_index = self.source_file_index(file_lo);
813 TAG_VALID_SPAN.encode(self)?;
814 source_file_index.encode(self)?;
815 line_lo.encode(self)?;
816 col_lo.encode(self)?;
819 if span_data.ctxt == SyntaxContext::empty() {
820 TAG_NO_EXPANSION_INFO.encode(self)
822 let (expn_id, expn_info) = span_data.ctxt.outer_expn_with_info();
823 if let Some(expn_info) = expn_info {
824 if let Some(pos) = self.expn_info_shorthands.get(&expn_id).cloned() {
825 TAG_EXPANSION_INFO_SHORTHAND.encode(self)?;
828 TAG_EXPANSION_INFO_INLINE.encode(self)?;
829 let pos = AbsoluteBytePos::new(self.position());
830 self.expn_info_shorthands.insert(expn_id, pos);
831 expn_info.encode(self)
834 TAG_NO_EXPANSION_INFO.encode(self)
840 impl<'a, 'tcx, E> ty_codec::TyEncoder for CacheEncoder<'a, 'tcx, E>
842 E: 'a + ty_codec::TyEncoder,
845 fn position(&self) -> usize {
846 self.encoder.position()
850 impl<'a, 'tcx, E> SpecializedEncoder<CrateNum> for CacheEncoder<'a, 'tcx, E>
852 E: 'a + ty_codec::TyEncoder,
855 fn specialized_encode(&mut self, cnum: &CrateNum) -> Result<(), Self::Error> {
856 self.emit_u32(cnum.as_u32())
860 impl<'a, 'tcx, E> SpecializedEncoder<Ty<'tcx>> for CacheEncoder<'a, 'tcx, E>
862 E: 'a + ty_codec::TyEncoder,
865 fn specialized_encode(&mut self, ty: &Ty<'tcx>) -> Result<(), Self::Error> {
866 ty_codec::encode_with_shorthand(self, ty,
867 |encoder| &mut encoder.type_shorthands)
871 impl<'a, 'tcx, E> SpecializedEncoder<ty::GenericPredicates<'tcx>> for CacheEncoder<'a, 'tcx, E>
873 E: 'a + ty_codec::TyEncoder,
876 fn specialized_encode(&mut self,
877 predicates: &ty::GenericPredicates<'tcx>)
878 -> Result<(), Self::Error> {
879 ty_codec::encode_predicates(self, predicates,
880 |encoder| &mut encoder.predicate_shorthands)
884 impl<'a, 'tcx, E> SpecializedEncoder<hir::HirId> for CacheEncoder<'a, 'tcx, E>
886 E: 'a + ty_codec::TyEncoder,
889 fn specialized_encode(&mut self, id: &hir::HirId) -> Result<(), Self::Error> {
895 let def_path_hash = self.tcx.hir().definitions().def_path_hash(owner);
897 def_path_hash.encode(self)?;
898 local_id.encode(self)
902 impl<'a, 'tcx, E> SpecializedEncoder<DefId> for CacheEncoder<'a, 'tcx, E>
904 E: 'a + ty_codec::TyEncoder,
907 fn specialized_encode(&mut self, id: &DefId) -> Result<(), Self::Error> {
908 let def_path_hash = self.tcx.def_path_hash(*id);
909 def_path_hash.encode(self)
913 impl<'a, 'tcx, E> SpecializedEncoder<LocalDefId> for CacheEncoder<'a, 'tcx, E>
915 E: 'a + ty_codec::TyEncoder,
918 fn specialized_encode(&mut self, id: &LocalDefId) -> Result<(), Self::Error> {
919 id.to_def_id().encode(self)
923 impl<'a, 'tcx, E> SpecializedEncoder<DefIndex> for CacheEncoder<'a, 'tcx, E>
925 E: 'a + ty_codec::TyEncoder,
927 fn specialized_encode(&mut self, _: &DefIndex) -> Result<(), Self::Error> {
928 bug!("Encoding DefIndex without context.")
932 // NodeIds are not stable across compilation sessions, so we store them in their
933 // HirId representation. This allows use to map them to the current NodeId.
934 impl<'a, 'tcx, E> SpecializedEncoder<NodeId> for CacheEncoder<'a, 'tcx, E>
936 E: 'a + ty_codec::TyEncoder,
939 fn specialized_encode(&mut self, node_id: &NodeId) -> Result<(), Self::Error> {
940 let hir_id = self.tcx.hir().node_to_hir_id(*node_id);
945 impl<'a, 'tcx> SpecializedEncoder<Fingerprint> for CacheEncoder<'a, 'tcx, opaque::Encoder> {
946 fn specialized_encode(&mut self, f: &Fingerprint) -> Result<(), Self::Error> {
947 f.encode_opaque(&mut self.encoder)
951 impl<'a, 'tcx, E, T> SpecializedEncoder<mir::ClearCrossCrate<T>> for CacheEncoder<'a, 'tcx, E>
953 E: 'a + ty_codec::TyEncoder,
957 fn specialized_encode(&mut self,
958 val: &mir::ClearCrossCrate<T>)
959 -> Result<(), Self::Error> {
961 mir::ClearCrossCrate::Clear => {
962 TAG_CLEAR_CROSS_CRATE_CLEAR.encode(self)
964 mir::ClearCrossCrate::Set(ref val) => {
965 TAG_CLEAR_CROSS_CRATE_SET.encode(self)?;
972 macro_rules! encoder_methods {
973 ($($name:ident($ty:ty);)*) => {
974 $(fn $name(&mut self, value: $ty) -> Result<(), Self::Error> {
975 self.encoder.$name(value)
980 impl<'a, 'tcx, E> Encoder for CacheEncoder<'a, 'tcx, E>
982 E: 'a + ty_codec::TyEncoder,
984 type Error = E::Error;
986 fn emit_unit(&mut self) -> Result<(), Self::Error> {
1013 // An integer that will always encode to 8 bytes.
1014 struct IntEncodedWithFixedSize(u64);
1016 impl IntEncodedWithFixedSize {
1017 pub const ENCODED_SIZE: usize = 8;
1020 impl UseSpecializedEncodable for IntEncodedWithFixedSize {}
1021 impl UseSpecializedDecodable for IntEncodedWithFixedSize {}
1023 impl SpecializedEncoder<IntEncodedWithFixedSize> for opaque::Encoder {
1024 fn specialized_encode(&mut self, x: &IntEncodedWithFixedSize) -> Result<(), Self::Error> {
1025 let start_pos = self.position();
1026 for i in 0 .. IntEncodedWithFixedSize::ENCODED_SIZE {
1027 ((x.0 >> i * 8) as u8).encode(self)?;
1029 let end_pos = self.position();
1030 assert_eq!((end_pos - start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
1035 impl<'a> SpecializedDecoder<IntEncodedWithFixedSize> for opaque::Decoder<'a> {
1036 fn specialized_decode(&mut self) -> Result<IntEncodedWithFixedSize, Self::Error> {
1037 let mut value: u64 = 0;
1038 let start_pos = self.position();
1040 for i in 0 .. IntEncodedWithFixedSize::ENCODED_SIZE {
1041 let byte: u8 = Decodable::decode(self)?;
1042 value |= (byte as u64) << (i * 8);
1045 let end_pos = self.position();
1046 assert_eq!((end_pos - start_pos), IntEncodedWithFixedSize::ENCODED_SIZE);
1048 Ok(IntEncodedWithFixedSize(value))
1052 fn encode_query_results<'a, 'tcx, Q, E>(
1054 encoder: &mut CacheEncoder<'a, 'tcx, E>,
1055 query_result_index: &mut EncodedQueryResultIndex,
1056 ) -> Result<(), E::Error>
1058 Q: super::config::QueryDescription<'tcx>,
1060 Q::Value: Encodable,
1062 let desc = &format!("encode_query_results for {}",
1063 unsafe { ::std::intrinsics::type_name::<Q>() });
1065 time_ext(tcx.sess.time_extended(), Some(tcx.sess), desc, || {
1066 let map = Q::query_cache(tcx).borrow();
1067 assert!(map.active.is_empty());
1068 for (key, entry) in map.results.iter() {
1069 if Q::cache_on_disk(tcx, key.clone(), Some(&entry.value)) {
1070 let dep_node = SerializedDepNodeIndex::new(entry.index.index());
1072 // Record position of the cache entry
1073 query_result_index.push((dep_node, AbsoluteBytePos::new(encoder.position())));
1075 // Encode the type check tables with the SerializedDepNodeIndex
1077 encoder.encode_tagged(dep_node, &entry.value)?;