2 use rustc_data_structures
::fx
::{FxHashMap, 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_data_structures
::unord
::UnordSet
;
7 use rustc_hir
::def_id
::{CrateNum, DefId, DefIndex, LocalDefId, StableCrateId, LOCAL_CRATE}
;
8 use rustc_hir
::definitions
::DefPathHash
;
9 use rustc_index
::vec
::{Idx, IndexVec}
;
10 use rustc_middle
::dep_graph
::{DepNodeIndex, SerializedDepNodeIndex}
;
11 use rustc_middle
::mir
::interpret
::{AllocDecodingSession, AllocDecodingState}
;
12 use rustc_middle
::mir
::{self, interpret}
;
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
::{QueryCache, QueryContext, QuerySideEffects}
;
17 use rustc_serialize
::{
18 opaque
::{FileEncodeResult, FileEncoder, IntEncodedWithFixedSize, MemDecoder}
,
19 Decodable
, Decoder
, Encodable
, Encoder
,
21 use rustc_session
::Session
;
22 use rustc_span
::hygiene
::{
23 ExpnId
, HygieneDecodeContext
, HygieneEncodeContext
, SyntaxContext
, SyntaxContextData
,
25 use rustc_span
::source_map
::{SourceMap, StableSourceFileId}
;
26 use rustc_span
::{BytePos, ExpnData, ExpnHash, Pos, SourceFile, Span}
;
27 use rustc_span
::{CachingSourceMapView, Symbol}
;
28 use std
::collections
::hash_map
::Entry
;
32 const TAG_FILE_FOOTER
: u128
= 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
34 // A normal span encoded with both location information and a `SyntaxContext`
35 const TAG_FULL_SPAN
: u8 = 0;
36 // A partial span with no location information, encoded only with a `SyntaxContext`
37 const TAG_PARTIAL_SPAN
: u8 = 1;
38 const TAG_RELATIVE_SPAN
: u8 = 2;
40 const TAG_SYNTAX_CONTEXT
: u8 = 0;
41 const TAG_EXPN_DATA
: u8 = 1;
43 // Tags for encoding Symbol's
44 const SYMBOL_STR
: u8 = 0;
45 const SYMBOL_OFFSET
: u8 = 1;
46 const SYMBOL_PREINTERNED
: u8 = 2;
48 /// Provides an interface to incremental compilation data cached from the
49 /// previous compilation session. This data will eventually include the results
50 /// of a few selected queries (like `typeck` and `mir_optimized`) and
51 /// any side effects that have been emitted during a query.
52 pub struct OnDiskCache
<'sess
> {
53 // The complete cache data in serialized form.
54 serialized_data
: RwLock
<Option
<Mmap
>>,
56 // Collects all `QuerySideEffects` created during the current compilation
58 current_side_effects
: Lock
<FxHashMap
<DepNodeIndex
, QuerySideEffects
>>,
60 source_map
: &'sess SourceMap
,
61 file_index_to_stable_id
: FxHashMap
<SourceFileIndex
, EncodedSourceFileId
>,
63 // Caches that are populated lazily during decoding.
64 file_index_to_file
: Lock
<FxHashMap
<SourceFileIndex
, Lrc
<SourceFile
>>>,
66 // A map from dep-node to the position of the cached query result in
68 query_result_index
: FxHashMap
<SerializedDepNodeIndex
, AbsoluteBytePos
>,
70 // A map from dep-node to the position of any associated `QuerySideEffects` in
72 prev_side_effects_index
: FxHashMap
<SerializedDepNodeIndex
, AbsoluteBytePos
>,
74 alloc_decoding_state
: AllocDecodingState
,
76 // A map from syntax context ids to the position of their associated
77 // `SyntaxContextData`. We use a `u32` instead of a `SyntaxContext`
78 // to represent the fact that we are storing *encoded* ids. When we decode
79 // a `SyntaxContext`, a new id will be allocated from the global `HygieneData`,
80 // which will almost certainly be different than the serialized id.
81 syntax_contexts
: FxHashMap
<u32, AbsoluteBytePos
>,
82 // A map from the `DefPathHash` of an `ExpnId` to the position
83 // of their associated `ExpnData`. Ideally, we would store a `DefId`,
84 // but we need to decode this before we've constructed a `TyCtxt` (which
85 // makes it difficult to decode a `DefId`).
87 // Note that these `DefPathHashes` correspond to both local and foreign
88 // `ExpnData` (e.g `ExpnData.krate` may not be `LOCAL_CRATE`). Alternatively,
89 // we could look up the `ExpnData` from the metadata of foreign crates,
90 // but it seemed easier to have `OnDiskCache` be independent of the `CStore`.
91 expn_data
: UnhashMap
<ExpnHash
, AbsoluteBytePos
>,
92 // Additional information used when decoding hygiene data.
93 hygiene_context
: HygieneDecodeContext
,
94 // Maps `ExpnHash`es to their raw value from the *previous*
95 // compilation session. This is used as an initial 'guess' when
96 // we try to map an `ExpnHash` to its value in the current
97 // compilation session.
98 foreign_expn_data
: UnhashMap
<ExpnHash
, u32>,
101 // This type is used only for serialization and deserialization.
102 #[derive(Encodable, Decodable)]
104 file_index_to_stable_id
: FxHashMap
<SourceFileIndex
, EncodedSourceFileId
>,
105 query_result_index
: EncodedDepNodeIndex
,
106 side_effects_index
: EncodedDepNodeIndex
,
107 // The location of all allocations.
108 interpret_alloc_index
: Vec
<u32>,
109 // See `OnDiskCache.syntax_contexts`
110 syntax_contexts
: FxHashMap
<u32, AbsoluteBytePos
>,
111 // See `OnDiskCache.expn_data`
112 expn_data
: UnhashMap
<ExpnHash
, AbsoluteBytePos
>,
113 foreign_expn_data
: UnhashMap
<ExpnHash
, u32>,
116 pub type EncodedDepNodeIndex
= Vec
<(SerializedDepNodeIndex
, AbsoluteBytePos
)>;
118 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Encodable, Decodable)]
119 struct SourceFileIndex(u32);
121 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Encodable, Decodable)]
122 pub struct AbsoluteBytePos(u64);
124 impl AbsoluteBytePos
{
125 fn new(pos
: usize) -> AbsoluteBytePos
{
126 AbsoluteBytePos(pos
.try_into().expect("Incremental cache file size overflowed u64."))
129 fn to_usize(self) -> usize {
134 /// An `EncodedSourceFileId` is the same as a `StableSourceFileId` except that
135 /// the source crate is represented as a [StableCrateId] instead of as a
136 /// `CrateNum`. This way `EncodedSourceFileId` can be encoded and decoded
137 /// without any additional context, i.e. with a simple `opaque::Decoder` (which
138 /// is the only thing available when decoding the cache's [Footer].
139 #[derive(Encodable, Decodable, Clone, Debug)]
140 struct EncodedSourceFileId
{
142 stable_crate_id
: StableCrateId
,
145 impl EncodedSourceFileId
{
146 fn translate(&self, tcx
: TyCtxt
<'_
>) -> StableSourceFileId
{
147 let cnum
= tcx
.stable_crate_id_to_crate_num(self.stable_crate_id
);
148 StableSourceFileId { file_name_hash: self.file_name_hash, cnum }
151 fn new(tcx
: TyCtxt
<'_
>, file
: &SourceFile
) -> EncodedSourceFileId
{
152 let source_file_id
= StableSourceFileId
::new(file
);
153 EncodedSourceFileId
{
154 file_name_hash
: source_file_id
.file_name_hash
,
155 stable_crate_id
: tcx
.stable_crate_id(source_file_id
.cnum
),
160 impl<'sess
> rustc_middle
::ty
::OnDiskCache
<'sess
> for OnDiskCache
<'sess
> {
161 /// Creates a new `OnDiskCache` instance from the serialized data in `data`.
162 fn new(sess
: &'sess Session
, data
: Mmap
, start_pos
: usize) -> Self {
163 debug_assert
!(sess
.opts
.incremental
.is_some());
165 // Wrap in a scope so we can borrow `data`.
166 let footer
: Footer
= {
167 let mut decoder
= MemDecoder
::new(&data
, start_pos
);
169 // Decode the *position* of the footer, which can be found in the
170 // last 8 bytes of the file.
171 decoder
.set_position(data
.len() - IntEncodedWithFixedSize
::ENCODED_SIZE
);
172 let footer_pos
= IntEncodedWithFixedSize
::decode(&mut decoder
).0 as usize;
174 // Decode the file footer, which contains all the lookup tables, etc.
175 decoder
.set_position(footer_pos
);
177 decode_tagged(&mut decoder
, TAG_FILE_FOOTER
)
181 serialized_data
: RwLock
::new(Some(data
)),
182 file_index_to_stable_id
: footer
.file_index_to_stable_id
,
183 file_index_to_file
: Default
::default(),
184 source_map
: sess
.source_map(),
185 current_side_effects
: Default
::default(),
186 query_result_index
: footer
.query_result_index
.into_iter().collect(),
187 prev_side_effects_index
: footer
.side_effects_index
.into_iter().collect(),
188 alloc_decoding_state
: AllocDecodingState
::new(footer
.interpret_alloc_index
),
189 syntax_contexts
: footer
.syntax_contexts
,
190 expn_data
: footer
.expn_data
,
191 foreign_expn_data
: footer
.foreign_expn_data
,
192 hygiene_context
: Default
::default(),
196 fn new_empty(source_map
: &'sess SourceMap
) -> Self {
198 serialized_data
: RwLock
::new(None
),
199 file_index_to_stable_id
: Default
::default(),
200 file_index_to_file
: Default
::default(),
202 current_side_effects
: Default
::default(),
203 query_result_index
: Default
::default(),
204 prev_side_effects_index
: Default
::default(),
205 alloc_decoding_state
: AllocDecodingState
::new(Vec
::new()),
206 syntax_contexts
: FxHashMap
::default(),
207 expn_data
: UnhashMap
::default(),
208 foreign_expn_data
: UnhashMap
::default(),
209 hygiene_context
: Default
::default(),
213 /// Execute all cache promotions and release the serialized backing Mmap.
215 /// Cache promotions require invoking queries, which needs to read the serialized data.
216 /// In order to serialize the new on-disk cache, the former on-disk cache file needs to be
217 /// deleted, hence we won't be able to refer to its memmapped data.
218 fn drop_serialized_data(&self, tcx
: TyCtxt
<'_
>) {
219 // Load everything into memory so we can write it out to the on-disk
220 // cache. The vast majority of cacheable query results should already
221 // be in memory, so this should be a cheap operation.
222 // Do this *before* we clone 'latest_foreign_def_path_hashes', since
223 // loading existing queries may cause us to create new DepNodes, which
224 // may in turn end up invoking `store_foreign_def_id_hash`
225 tcx
.dep_graph
.exec_cache_promotions(tcx
);
227 *self.serialized_data
.write() = None
;
230 fn serialize(&self, tcx
: TyCtxt
<'_
>, encoder
: FileEncoder
) -> FileEncodeResult
{
231 // Serializing the `DepGraph` should not modify it.
232 tcx
.dep_graph
.with_ignore(|| {
233 // Allocate `SourceFileIndex`es.
234 let (file_to_file_index
, file_index_to_stable_id
) = {
235 let files
= tcx
.sess
.source_map().files();
236 let mut file_to_file_index
=
237 FxHashMap
::with_capacity_and_hasher(files
.len(), Default
::default());
238 let mut file_index_to_stable_id
=
239 FxHashMap
::with_capacity_and_hasher(files
.len(), Default
::default());
241 for (index
, file
) in files
.iter().enumerate() {
242 let index
= SourceFileIndex(index
as u32);
243 let file_ptr
: *const SourceFile
= &**file
as *const _
;
244 file_to_file_index
.insert(file_ptr
, index
);
245 let source_file_id
= EncodedSourceFileId
::new(tcx
, &file
);
246 file_index_to_stable_id
.insert(index
, source_file_id
);
249 (file_to_file_index
, file_index_to_stable_id
)
252 let hygiene_encode_context
= HygieneEncodeContext
::default();
254 let mut encoder
= CacheEncoder
{
257 type_shorthands
: Default
::default(),
258 predicate_shorthands
: Default
::default(),
259 interpret_allocs
: Default
::default(),
260 source_map
: CachingSourceMapView
::new(tcx
.sess
.source_map()),
262 hygiene_context
: &hygiene_encode_context
,
263 symbol_table
: Default
::default(),
266 // Encode query results.
267 let mut query_result_index
= EncodedDepNodeIndex
::new();
269 tcx
.sess
.time("encode_query_results", || {
270 let enc
= &mut encoder
;
271 let qri
= &mut query_result_index
;
272 QueryCtxt
::from_tcx(tcx
).encode_query_results(enc
, qri
);
275 // Encode side effects.
276 let side_effects_index
: EncodedDepNodeIndex
= self
277 .current_side_effects
280 .map(|(dep_node_index
, side_effects
)| {
281 let pos
= AbsoluteBytePos
::new(encoder
.position());
282 let dep_node_index
= SerializedDepNodeIndex
::new(dep_node_index
.index());
283 encoder
.encode_tagged(dep_node_index
, side_effects
);
285 (dep_node_index
, pos
)
289 let interpret_alloc_index
= {
290 let mut interpret_alloc_index
= Vec
::new();
293 let new_n
= encoder
.interpret_allocs
.len();
294 // If we have found new IDs, serialize those too.
299 interpret_alloc_index
.reserve(new_n
- n
);
300 for idx
in n
..new_n
{
301 let id
= encoder
.interpret_allocs
[idx
];
302 let pos
= encoder
.position() as u32;
303 interpret_alloc_index
.push(pos
);
304 interpret
::specialized_encode_alloc_id(&mut encoder
, tcx
, id
);
308 interpret_alloc_index
311 let mut syntax_contexts
= FxHashMap
::default();
312 let mut expn_data
= UnhashMap
::default();
313 let mut foreign_expn_data
= UnhashMap
::default();
315 // Encode all hygiene data (`SyntaxContextData` and `ExpnData`) from the current
318 hygiene_encode_context
.encode(
320 |encoder
, index
, ctxt_data
| {
321 let pos
= AbsoluteBytePos
::new(encoder
.position());
322 encoder
.encode_tagged(TAG_SYNTAX_CONTEXT
, ctxt_data
);
323 syntax_contexts
.insert(index
, pos
);
325 |encoder
, expn_id
, data
, hash
| {
326 if expn_id
.krate
== LOCAL_CRATE
{
327 let pos
= AbsoluteBytePos
::new(encoder
.position());
328 encoder
.encode_tagged(TAG_EXPN_DATA
, data
);
329 expn_data
.insert(hash
, pos
);
331 foreign_expn_data
.insert(hash
, expn_id
.local_id
.as_u32());
336 // Encode the file footer.
337 let footer_pos
= encoder
.position() as u64;
338 encoder
.encode_tagged(
341 file_index_to_stable_id
,
344 interpret_alloc_index
,
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(&mut encoder
.encoder
);
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.
363 impl<'sess
> OnDiskCache
<'sess
> {
364 pub fn as_dyn(&self) -> &dyn rustc_middle
::ty
::OnDiskCache
<'sess
> {
368 /// Loads a `QuerySideEffects` created during the previous compilation session.
369 pub fn load_side_effects(
372 dep_node_index
: SerializedDepNodeIndex
,
373 ) -> QuerySideEffects
{
374 let side_effects
: Option
<QuerySideEffects
> =
375 self.load_indexed(tcx
, dep_node_index
, &self.prev_side_effects_index
);
377 side_effects
.unwrap_or_default()
380 /// Stores a `QuerySideEffects` emitted during the current compilation session.
381 /// Anything stored like this will be available via `load_side_effects` in
382 /// the next compilation session.
385 pub fn store_side_effects(&self, dep_node_index
: DepNodeIndex
, side_effects
: QuerySideEffects
) {
386 let mut current_side_effects
= self.current_side_effects
.borrow_mut();
387 let prev
= current_side_effects
.insert(dep_node_index
, side_effects
);
388 debug_assert
!(prev
.is_none());
391 /// Returns the cached query result if there is something in the cache for
392 /// the given `SerializedDepNodeIndex`; otherwise returns `None`.
393 pub fn try_load_query_result
<'tcx
, T
>(
396 dep_node_index
: SerializedDepNodeIndex
,
399 T
: for<'a
> Decodable
<CacheDecoder
<'a
, 'tcx
>>,
401 self.load_indexed(tcx
, dep_node_index
, &self.query_result_index
)
404 /// Stores side effect emitted during computation of an anonymous query.
405 /// Since many anonymous queries can share the same `DepNode`, we aggregate
406 /// them -- as opposed to regular queries where we assume that there is a
407 /// 1:1 relationship between query-key and `DepNode`.
410 pub fn store_side_effects_for_anon_node(
412 dep_node_index
: DepNodeIndex
,
413 side_effects
: QuerySideEffects
,
415 let mut current_side_effects
= self.current_side_effects
.borrow_mut();
417 let x
= current_side_effects
.entry(dep_node_index
).or_default();
418 x
.append(side_effects
);
421 fn load_indexed
<'tcx
, T
>(
424 dep_node_index
: SerializedDepNodeIndex
,
425 index
: &FxHashMap
<SerializedDepNodeIndex
, AbsoluteBytePos
>,
428 T
: for<'a
> Decodable
<CacheDecoder
<'a
, 'tcx
>>,
430 let pos
= index
.get(&dep_node_index
).cloned()?
;
432 self.with_decoder(tcx
, pos
, |decoder
| Some(decode_tagged(decoder
, dep_node_index
)))
435 fn with_decoder
<'a
, 'tcx
, T
, F
: for<'s
> FnOnce(&mut CacheDecoder
<'s
, 'tcx
>) -> T
>(
438 pos
: AbsoluteBytePos
,
442 T
: Decodable
<CacheDecoder
<'a
, 'tcx
>>,
444 let serialized_data
= self.serialized_data
.read();
445 let mut decoder
= CacheDecoder
{
447 opaque
: MemDecoder
::new(serialized_data
.as_deref().unwrap_or(&[]), pos
.to_usize()),
448 source_map
: self.source_map
,
449 file_index_to_file
: &self.file_index_to_file
,
450 file_index_to_stable_id
: &self.file_index_to_stable_id
,
451 alloc_decoding_session
: self.alloc_decoding_state
.new_decoding_session(),
452 syntax_contexts
: &self.syntax_contexts
,
453 expn_data
: &self.expn_data
,
454 foreign_expn_data
: &self.foreign_expn_data
,
455 hygiene_context
: &self.hygiene_context
,
461 //- DECODING -------------------------------------------------------------------
463 /// A decoder that can read from the incremental compilation cache. It is similar to the one
464 /// we use for crate metadata decoding in that it can rebase spans and eventually
465 /// will also handle things that contain `Ty` instances.
466 pub struct CacheDecoder
<'a
, 'tcx
> {
468 opaque
: MemDecoder
<'a
>,
469 source_map
: &'a SourceMap
,
470 file_index_to_file
: &'a Lock
<FxHashMap
<SourceFileIndex
, Lrc
<SourceFile
>>>,
471 file_index_to_stable_id
: &'a FxHashMap
<SourceFileIndex
, EncodedSourceFileId
>,
472 alloc_decoding_session
: AllocDecodingSession
<'a
>,
473 syntax_contexts
: &'a FxHashMap
<u32, AbsoluteBytePos
>,
474 expn_data
: &'a UnhashMap
<ExpnHash
, AbsoluteBytePos
>,
475 foreign_expn_data
: &'a UnhashMap
<ExpnHash
, u32>,
476 hygiene_context
: &'a HygieneDecodeContext
,
479 impl<'a
, 'tcx
> CacheDecoder
<'a
, 'tcx
> {
480 fn file_index_to_file(&self, index
: SourceFileIndex
) -> Lrc
<SourceFile
> {
483 ref file_index_to_file
,
484 ref file_index_to_stable_id
,
493 let stable_id
= file_index_to_stable_id
[&index
].translate(tcx
);
495 // If this `SourceFile` is from a foreign crate, then make sure
496 // that we've imported all of the source files from that crate.
497 // This has usually already been done during macro invocation.
498 // However, when encoding query results like `TypeckResults`,
499 // we might encode an `AdtDef` for a foreign type (because it
500 // was referenced in the body of the function). There is no guarantee
501 // that we will load the source files from that crate during macro
502 // expansion, so we use `import_source_files` to ensure that the foreign
503 // source files are actually imported before we call `source_file_by_stable_id`.
504 if stable_id
.cnum
!= LOCAL_CRATE
{
505 self.tcx
.cstore_untracked().import_source_files(self.tcx
.sess
, stable_id
.cnum
);
509 .source_file_by_stable_id(stable_id
)
510 .expect("failed to lookup `SourceFile` in new context")
516 trait DecoderWithPosition
: Decoder
{
517 fn position(&self) -> usize;
520 impl<'a
> DecoderWithPosition
for MemDecoder
<'a
> {
521 fn position(&self) -> usize {
526 impl<'a
, 'tcx
> DecoderWithPosition
for CacheDecoder
<'a
, 'tcx
> {
527 fn position(&self) -> usize {
528 self.opaque
.position()
532 // Decodes something that was encoded with `encode_tagged()` and verify that the
533 // tag matches and the correct amount of bytes was read.
534 fn decode_tagged
<D
, T
, V
>(decoder
: &mut D
, expected_tag
: T
) -> V
536 T
: Decodable
<D
> + Eq
+ std
::fmt
::Debug
,
538 D
: DecoderWithPosition
,
540 let start_pos
= decoder
.position();
542 let actual_tag
= T
::decode(decoder
);
543 assert_eq
!(actual_tag
, expected_tag
);
544 let value
= V
::decode(decoder
);
545 let end_pos
= decoder
.position();
547 let expected_len
: u64 = Decodable
::decode(decoder
);
548 assert_eq
!((end_pos
- start_pos
) as u64, expected_len
);
553 impl<'a
, 'tcx
> TyDecoder
for CacheDecoder
<'a
, 'tcx
> {
554 type I
= TyCtxt
<'tcx
>;
555 const CLEAR_CROSS_CRATE
: bool
= false;
558 fn interner(&self) -> TyCtxt
<'tcx
> {
563 fn position(&self) -> usize {
564 self.opaque
.position()
568 fn peek_byte(&self) -> u8 {
569 self.opaque
.data
[self.opaque
.position()]
572 fn cached_ty_for_shorthand
<F
>(&mut self, shorthand
: usize, or_insert_with
: F
) -> Ty
<'tcx
>
574 F
: FnOnce(&mut Self) -> Ty
<'tcx
>,
578 let cache_key
= ty
::CReaderCacheKey { cnum: None, pos: shorthand }
;
580 if let Some(&ty
) = tcx
.ty_rcache
.borrow().get(&cache_key
) {
584 let ty
= or_insert_with(self);
585 // This may overwrite the entry, but it should overwrite with the same value.
586 tcx
.ty_rcache
.borrow_mut().insert_same(cache_key
, ty
);
590 fn with_position
<F
, R
>(&mut self, pos
: usize, f
: F
) -> R
592 F
: FnOnce(&mut Self) -> R
,
594 debug_assert
!(pos
< self.opaque
.data
.len());
596 let new_opaque
= MemDecoder
::new(self.opaque
.data
, pos
);
597 let old_opaque
= mem
::replace(&mut self.opaque
, new_opaque
);
599 self.opaque
= old_opaque
;
603 fn decode_alloc_id(&mut self) -> interpret
::AllocId
{
604 let alloc_decoding_session
= self.alloc_decoding_session
;
605 alloc_decoding_session
.decode_alloc_id(self)
609 rustc_middle
::implement_ty_decoder
!(CacheDecoder
<'a
, 'tcx
>);
611 // This ensures that the `Decodable<opaque::Decoder>::decode` specialization for `Vec<u8>` is used
612 // when a `CacheDecoder` is passed to `Decodable::decode`. Unfortunately, we have to manually opt
613 // into specializations this way, given how `CacheDecoder` and the decoding traits currently work.
614 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for Vec
<u8> {
615 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
616 Decodable
::decode(&mut d
.opaque
)
620 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for SyntaxContext
{
621 fn decode(decoder
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
622 let syntax_contexts
= decoder
.syntax_contexts
;
623 rustc_span
::hygiene
::decode_syntax_context(decoder
, decoder
.hygiene_context
, |this
, id
| {
624 // This closure is invoked if we haven't already decoded the data for the `SyntaxContext` we are deserializing.
625 // We look up the position of the associated `SyntaxData` and decode it.
626 let pos
= syntax_contexts
.get(&id
).unwrap();
627 this
.with_position(pos
.to_usize(), |decoder
| {
628 let data
: SyntaxContextData
= decode_tagged(decoder
, TAG_SYNTAX_CONTEXT
);
635 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for ExpnId
{
636 fn decode(decoder
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
637 let hash
= ExpnHash
::decode(decoder
);
639 return ExpnId
::root();
642 if let Some(expn_id
) = ExpnId
::from_hash(hash
) {
646 let krate
= decoder
.tcx
.stable_crate_id_to_crate_num(hash
.stable_crate_id());
648 let expn_id
= if krate
== LOCAL_CRATE
{
649 // We look up the position of the associated `ExpnData` and decode it.
653 .unwrap_or_else(|| panic
!("Bad hash {:?} (map {:?})", hash
, decoder
.expn_data
));
655 let data
: ExpnData
= decoder
656 .with_position(pos
.to_usize(), |decoder
| decode_tagged(decoder
, TAG_EXPN_DATA
));
657 let expn_id
= rustc_span
::hygiene
::register_local_expn_id(data
, hash
);
659 #[cfg(debug_assertions)]
661 use rustc_data_structures
::stable_hasher
::{HashStable, StableHasher}
;
662 let local_hash
: u64 = decoder
.tcx
.with_stable_hashing_context(|mut hcx
| {
663 let mut hasher
= StableHasher
::new();
664 expn_id
.expn_data().hash_stable(&mut hcx
, &mut hasher
);
667 debug_assert_eq
!(hash
.local_hash(), local_hash
);
672 let index_guess
= decoder
.foreign_expn_data
[&hash
];
673 decoder
.tcx
.cstore_untracked().expn_hash_to_expn_id(
681 debug_assert_eq
!(expn_id
.krate
, krate
);
686 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for Span
{
687 fn decode(decoder
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
688 let ctxt
= SyntaxContext
::decode(decoder
);
689 let parent
= Option
::<LocalDefId
>::decode(decoder
);
690 let tag
: u8 = Decodable
::decode(decoder
);
692 if tag
== TAG_PARTIAL_SPAN
{
693 return Span
::new(BytePos(0), BytePos(0), ctxt
, parent
);
694 } else if tag
== TAG_RELATIVE_SPAN
{
695 let dlo
= u32::decode(decoder
);
696 let dto
= u32::decode(decoder
);
698 let enclosing
= decoder
.tcx
.source_span_untracked(parent
.unwrap()).data_untracked();
699 let span
= Span
::new(
700 enclosing
.lo
+ BytePos
::from_u32(dlo
),
701 enclosing
.lo
+ BytePos
::from_u32(dto
),
708 debug_assert_eq
!(tag
, TAG_FULL_SPAN
);
711 let file_lo_index
= SourceFileIndex
::decode(decoder
);
712 let line_lo
= usize::decode(decoder
);
713 let col_lo
= BytePos
::decode(decoder
);
714 let len
= BytePos
::decode(decoder
);
716 let file_lo
= decoder
.file_index_to_file(file_lo_index
);
717 let lo
= file_lo
.lines(|lines
| lines
[line_lo
- 1] + col_lo
);
720 Span
::new(lo
, hi
, ctxt
, parent
)
724 // copy&paste impl from rustc_metadata
725 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for Symbol
{
726 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
727 let tag
= d
.read_u8();
731 let s
= d
.read_str();
736 let pos
= d
.read_usize();
737 let old_pos
= d
.opaque
.position();
739 // move to str ofset and read
740 d
.opaque
.set_position(pos
);
741 let s
= d
.read_str();
742 let sym
= Symbol
::intern(s
);
745 d
.opaque
.set_position(old_pos
);
749 SYMBOL_PREINTERNED
=> {
750 let symbol_index
= d
.read_u32();
751 Symbol
::new_from_decoded(symbol_index
)
758 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for CrateNum
{
759 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
760 let stable_id
= StableCrateId
::decode(d
);
761 let cnum
= d
.tcx
.stable_crate_id_to_crate_num(stable_id
);
766 // This impl makes sure that we get a runtime error when we try decode a
767 // `DefIndex` that is not contained in a `DefId`. Such a case would be problematic
768 // because we would not know how to transform the `DefIndex` to the current
770 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for DefIndex
{
771 fn decode(_d
: &mut CacheDecoder
<'a
, 'tcx
>) -> DefIndex
{
772 panic
!("trying to decode `DefIndex` outside the context of a `DefId`")
776 // Both the `CrateNum` and the `DefIndex` of a `DefId` can change in between two
777 // compilation sessions. We use the `DefPathHash`, which is stable across
778 // sessions, to map the old `DefId` to the new one.
779 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for DefId
{
780 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
781 // Load the `DefPathHash` which is was we encoded the `DefId` as.
782 let def_path_hash
= DefPathHash
::decode(d
);
784 // Using the `DefPathHash`, we can lookup the new `DefId`.
785 // Subtle: We only encode a `DefId` as part of a query result.
786 // If we get to this point, then all of the query inputs were green,
787 // which means that the definition with this hash is guaranteed to
788 // still exist in the current compilation session.
789 d
.tcx
.def_path_hash_to_def_id(def_path_hash
, &mut || {
790 panic
!("Failed to convert DefPathHash {def_path_hash:?}")
795 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx UnordSet
<LocalDefId
> {
796 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
797 RefDecodable
::decode(d
)
801 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx FxHashMap
<DefId
, Ty
<'tcx
>> {
802 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
803 RefDecodable
::decode(d
)
807 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>>
808 for &'tcx IndexVec
<mir
::Promoted
, mir
::Body
<'tcx
>>
810 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
811 RefDecodable
::decode(d
)
815 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx
[(ty
::Predicate
<'tcx
>, Span
)] {
816 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
817 RefDecodable
::decode(d
)
821 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx
[(ty
::Clause
<'tcx
>, Span
)] {
822 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
823 RefDecodable
::decode(d
)
827 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx
[rustc_ast
::InlineAsmTemplatePiece
] {
828 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Self {
829 RefDecodable
::decode(d
)
833 macro_rules
! impl_ref_decoder
{
834 (<$tcx
:tt
> $
($ty
:ty
,)*) => {
835 $
(impl<'a
, $tcx
> Decodable
<CacheDecoder
<'a
, $tcx
>> for &$tcx
[$ty
] {
836 fn decode(d
: &mut CacheDecoder
<'a
, $tcx
>) -> Self {
837 RefDecodable
::decode(d
)
843 impl_ref_decoder
! {<'tcx
>
845 rustc_ast
::Attribute
,
846 rustc_span
::symbol
::Ident
,
848 rustc_span
::def_id
::DefId
,
849 rustc_span
::def_id
::LocalDefId
,
850 (rustc_middle
::middle
::exported_symbols
::ExportedSymbol
<'tcx
>, rustc_middle
::middle
::exported_symbols
::SymbolExportInfo
),
851 ty
::DeducedParamAttrs
,
854 //- ENCODING -------------------------------------------------------------------
856 /// An encoder that can write to the incremental compilation cache.
857 pub struct CacheEncoder
<'a
, 'tcx
> {
859 encoder
: FileEncoder
,
860 type_shorthands
: FxHashMap
<Ty
<'tcx
>, usize>,
861 predicate_shorthands
: FxHashMap
<ty
::PredicateKind
<'tcx
>, usize>,
862 interpret_allocs
: FxIndexSet
<interpret
::AllocId
>,
863 source_map
: CachingSourceMapView
<'tcx
>,
864 file_to_file_index
: FxHashMap
<*const SourceFile
, SourceFileIndex
>,
865 hygiene_context
: &'a HygieneEncodeContext
,
866 symbol_table
: FxHashMap
<Symbol
, usize>,
869 impl<'a
, 'tcx
> CacheEncoder
<'a
, 'tcx
> {
870 fn source_file_index(&mut self, source_file
: Lrc
<SourceFile
>) -> SourceFileIndex
{
871 self.file_to_file_index
[&(&*source_file
as *const SourceFile
)]
874 /// Encode something with additional information that allows to do some
875 /// sanity checks when decoding the data again. This method will first
876 /// encode the specified tag, then the given value, then the number of
877 /// bytes taken up by tag and value. On decoding, we can then verify that
878 /// we get the expected tag and read the expected number of bytes.
879 fn encode_tagged
<T
: Encodable
<Self>, V
: Encodable
<Self>>(&mut self, tag
: T
, value
: &V
) {
880 let start_pos
= self.position();
885 let end_pos
= self.position();
886 ((end_pos
- start_pos
) as u64).encode(self);
889 fn finish(self) -> Result
<usize, io
::Error
> {
890 self.encoder
.finish()
894 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
>> for SyntaxContext
{
895 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
>) {
896 rustc_span
::hygiene
::raw_encode_syntax_context(*self, s
.hygiene_context
, s
);
900 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
>> for ExpnId
{
901 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
>) {
902 s
.hygiene_context
.schedule_expn_data_for_encoding(*self);
903 self.expn_hash().encode(s
);
907 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
>> for Span
{
908 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
>) {
909 let span_data
= self.data_untracked();
910 span_data
.ctxt
.encode(s
);
911 span_data
.parent
.encode(s
);
913 if span_data
.is_dummy() {
914 return TAG_PARTIAL_SPAN
.encode(s
);
917 if let Some(parent
) = span_data
.parent
{
918 let enclosing
= s
.tcx
.source_span(parent
).data_untracked();
919 if enclosing
.contains(span_data
) {
920 TAG_RELATIVE_SPAN
.encode(s
);
921 (span_data
.lo
- enclosing
.lo
).to_u32().encode(s
);
922 (span_data
.hi
- enclosing
.lo
).to_u32().encode(s
);
927 let pos
= s
.source_map
.byte_pos_to_line_and_col(span_data
.lo
);
928 let partial_span
= match &pos
{
929 Some((file_lo
, _
, _
)) => !file_lo
.contains(span_data
.hi
),
934 return TAG_PARTIAL_SPAN
.encode(s
);
937 let (file_lo
, line_lo
, col_lo
) = pos
.unwrap();
939 let len
= span_data
.hi
- span_data
.lo
;
941 let source_file_index
= s
.source_file_index(file_lo
);
943 TAG_FULL_SPAN
.encode(s
);
944 source_file_index
.encode(s
);
951 // copy&paste impl from rustc_metadata
952 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
>> for Symbol
{
953 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
>) {
954 // if symbol preinterned, emit tag and symbol index
955 if self.is_preinterned() {
956 s
.encoder
.emit_u8(SYMBOL_PREINTERNED
);
957 s
.encoder
.emit_u32(self.as_u32());
959 // otherwise write it as string or as offset to it
960 match s
.symbol_table
.entry(*self) {
961 Entry
::Vacant(o
) => {
962 s
.encoder
.emit_u8(SYMBOL_STR
);
963 let pos
= s
.encoder
.position();
965 s
.emit_str(self.as_str());
967 Entry
::Occupied(o
) => {
969 s
.emit_u8(SYMBOL_OFFSET
);
977 impl<'a
, 'tcx
> TyEncoder
for CacheEncoder
<'a
, 'tcx
> {
978 type I
= TyCtxt
<'tcx
>;
979 const CLEAR_CROSS_CRATE
: bool
= false;
981 fn position(&self) -> usize {
982 self.encoder
.position()
984 fn type_shorthands(&mut self) -> &mut FxHashMap
<Ty
<'tcx
>, usize> {
985 &mut self.type_shorthands
987 fn predicate_shorthands(&mut self) -> &mut FxHashMap
<ty
::PredicateKind
<'tcx
>, usize> {
988 &mut self.predicate_shorthands
990 fn encode_alloc_id(&mut self, alloc_id
: &interpret
::AllocId
) {
991 let (index
, _
) = self.interpret_allocs
.insert_full(*alloc_id
);
997 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
>> for CrateNum
{
998 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
>) {
999 s
.tcx
.stable_crate_id(*self).encode(s
);
1003 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
>> for DefId
{
1004 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
>) {
1005 s
.tcx
.def_path_hash(*self).encode(s
);
1009 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
>> for DefIndex
{
1010 fn encode(&self, _
: &mut CacheEncoder
<'a
, 'tcx
>) {
1011 bug
!("encoding `DefIndex` without context");
1015 macro_rules
! encoder_methods
{
1016 ($
($name
:ident($ty
:ty
);)*) => {
1018 $
(fn $
name(&mut self, value
: $ty
) {
1019 self.encoder
.$
name(value
)
1024 impl<'a
, 'tcx
> Encoder
for CacheEncoder
<'a
, 'tcx
> {
1045 emit_raw_bytes(&[u8]);
1049 // This ensures that the `Encodable<opaque::FileEncoder>::encode` specialization for byte slices
1050 // is used when a `CacheEncoder` having an `opaque::FileEncoder` is passed to `Encodable::encode`.
1051 // Unfortunately, we have to manually opt into specializations this way, given how `CacheEncoder`
1052 // and the encoding traits currently work.
1053 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
>> for [u8] {
1054 fn encode(&self, e
: &mut CacheEncoder
<'a
, 'tcx
>) {
1055 self.encode(&mut e
.encoder
);
1059 pub fn encode_query_results
<'a
, 'tcx
, CTX
, Q
>(
1061 encoder
: &mut CacheEncoder
<'a
, 'tcx
>,
1062 query_result_index
: &mut EncodedDepNodeIndex
,
1064 CTX
: QueryContext
+ 'tcx
,
1065 Q
: super::QueryConfig
<CTX
>,
1066 Q
::Value
: Encodable
<CacheEncoder
<'a
, 'tcx
>>,
1071 .verbose_generic_activity_with_arg("encode_query_results_for", std
::any
::type_name
::<Q
>());
1073 assert
!(Q
::query_state(tcx
).all_inactive());
1074 let cache
= Q
::query_cache(tcx
);
1075 cache
.iter(&mut |key
, value
, dep_node
| {
1076 if Q
::cache_on_disk(*tcx
.dep_context(), &key
) {
1077 let dep_node
= SerializedDepNodeIndex
::new(dep_node
.index());
1079 // Record position of the cache entry.
1080 query_result_index
.push((dep_node
, AbsoluteBytePos
::new(encoder
.encoder
.position())));
1082 // Encode the type check tables with the `SerializedDepNodeIndex`
1084 encoder
.encode_tagged(dep_node
, value
);