]>
Commit | Line | Data |
---|---|---|
ba9703b0 XL |
1 | //! This module defines the `DepNode` type which the compiler uses to represent |
2 | //! nodes in the dependency graph. A `DepNode` consists of a `DepKind` (which | |
3 | //! specifies the kind of thing it represents, like a piece of HIR, MIR, etc) | |
4 | //! and a `Fingerprint`, a 128 bit hash value the exact meaning of which | |
5 | //! depends on the node's `DepKind`. Together, the kind and the fingerprint | |
6 | //! fully identify a dependency node, even across multiple compilation sessions. | |
7 | //! In other words, the value of the fingerprint does not depend on anything | |
8 | //! that is specific to a given compilation session, like an unpredictable | |
9 | //! interning key (e.g., NodeId, DefId, Symbol) or the numeric value of a | |
10 | //! pointer. The concept behind this could be compared to how git commit hashes | |
11 | //! uniquely identify a given commit and has a few advantages: | |
12 | //! | |
13 | //! * A `DepNode` can simply be serialized to disk and loaded in another session | |
14 | //! without the need to do any "rebasing (like we have to do for Spans and | |
15 | //! NodeIds) or "retracing" like we had to do for `DefId` in earlier | |
16 | //! implementations of the dependency graph. | |
17 | //! * A `Fingerprint` is just a bunch of bits, which allows `DepNode` to | |
18 | //! implement `Copy`, `Sync`, `Send`, `Freeze`, etc. | |
19 | //! * Since we just have a bit pattern, `DepNode` can be mapped from disk into | |
20 | //! memory without any post-processing (e.g., "abomination-style" pointer | |
21 | //! reconstruction). | |
22 | //! * Because a `DepNode` is self-contained, we can instantiate `DepNodes` that | |
23 | //! refer to things that do not exist anymore. In previous implementations | |
24 | //! `DepNode` contained a `DefId`. A `DepNode` referring to something that | |
25 | //! had been removed between the previous and the current compilation session | |
26 | //! could not be instantiated because the current compilation session | |
27 | //! contained no `DefId` for thing that had been removed. | |
28 | //! | |
29 | //! `DepNode` definition happens in `librustc_middle` with the `define_dep_nodes!()` macro. | |
30 | //! This macro defines the `DepKind` enum and a corresponding `DepConstructor` enum. The | |
31 | //! `DepConstructor` enum links a `DepKind` to the parameters that are needed at runtime in order | |
32 | //! to construct a valid `DepNode` fingerprint. | |
33 | //! | |
34 | //! Because the macro sees what parameters a given `DepKind` requires, it can | |
35 | //! "infer" some properties for each kind of `DepNode`: | |
36 | //! | |
37 | //! * Whether a `DepNode` of a given kind has any parameters at all. Some | |
38 | //! `DepNode`s could represent global concepts with only one value. | |
39 | //! * Whether it is possible, in principle, to reconstruct a query key from a | |
40 | //! given `DepNode`. Many `DepKind`s only require a single `DefId` parameter, | |
41 | //! in which case it is possible to map the node's fingerprint back to the | |
42 | //! `DefId` it was computed from. In other cases, too much information gets | |
43 | //! lost during fingerprint computation. | |
44 | ||
45 | use super::{DepContext, DepKind}; | |
46 | ||
47 | use rustc_data_structures::fingerprint::Fingerprint; | |
48 | use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; | |
49 | ||
50 | use std::fmt; | |
51 | use std::hash::Hash; | |
52 | ||
3dfed10e | 53 | #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)] |
ba9703b0 XL |
54 | pub struct DepNode<K> { |
55 | pub kind: K, | |
56 | pub hash: Fingerprint, | |
57 | } | |
58 | ||
59 | impl<K: DepKind> DepNode<K> { | |
60 | /// Creates a new, parameterless DepNode. This method will assert | |
61 | /// that the DepNode corresponding to the given DepKind actually | |
62 | /// does not require any parameters. | |
63 | pub fn new_no_params(kind: K) -> DepNode<K> { | |
64 | debug_assert!(!kind.has_params()); | |
65 | DepNode { kind, hash: Fingerprint::ZERO } | |
66 | } | |
f9f354fc XL |
67 | |
68 | pub fn construct<Ctxt, Key>(tcx: Ctxt, kind: K, arg: &Key) -> DepNode<K> | |
69 | where | |
70 | Ctxt: crate::query::QueryContext<DepKind = K>, | |
71 | Key: DepNodeParams<Ctxt>, | |
72 | { | |
73 | let hash = arg.to_fingerprint(tcx); | |
74 | let dep_node = DepNode { kind, hash }; | |
75 | ||
76 | #[cfg(debug_assertions)] | |
77 | { | |
78 | if !kind.can_reconstruct_query_key() && tcx.debug_dep_node() { | |
79 | tcx.dep_graph().register_dep_node_debug_str(dep_node, || arg.to_debug_str(tcx)); | |
80 | } | |
81 | } | |
82 | ||
83 | dep_node | |
84 | } | |
ba9703b0 XL |
85 | } |
86 | ||
87 | impl<K: DepKind> fmt::Debug for DepNode<K> { | |
88 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { | |
89 | K::debug_node(self, f) | |
90 | } | |
91 | } | |
92 | ||
93 | pub trait DepNodeParams<Ctxt: DepContext>: fmt::Debug + Sized { | |
f035d41b | 94 | fn can_reconstruct_query_key() -> bool; |
ba9703b0 XL |
95 | |
96 | /// This method turns the parameters of a DepNodeConstructor into an opaque | |
97 | /// Fingerprint to be used in DepNode. | |
98 | /// Not all DepNodeParams support being turned into a Fingerprint (they | |
99 | /// don't need to if the corresponding DepNode is anonymous). | |
100 | fn to_fingerprint(&self, _: Ctxt) -> Fingerprint { | |
101 | panic!("Not implemented. Accidentally called on anonymous node?") | |
102 | } | |
103 | ||
104 | fn to_debug_str(&self, _: Ctxt) -> String { | |
105 | format!("{:?}", self) | |
106 | } | |
107 | ||
108 | /// This method tries to recover the query key from the given `DepNode`, | |
109 | /// something which is needed when forcing `DepNode`s during red-green | |
110 | /// evaluation. The query system will only call this method if | |
f035d41b | 111 | /// `can_reconstruct_query_key()` is `true`. |
ba9703b0 XL |
112 | /// It is always valid to return `None` here, in which case incremental |
113 | /// compilation will treat the query as having changed instead of forcing it. | |
114 | fn recover(tcx: Ctxt, dep_node: &DepNode<Ctxt::DepKind>) -> Option<Self>; | |
115 | } | |
116 | ||
117 | impl<Ctxt: DepContext, T> DepNodeParams<Ctxt> for T | |
118 | where | |
119 | T: HashStable<Ctxt::StableHashingContext> + fmt::Debug, | |
120 | { | |
f035d41b XL |
121 | #[inline] |
122 | default fn can_reconstruct_query_key() -> bool { | |
123 | false | |
124 | } | |
ba9703b0 XL |
125 | |
126 | default fn to_fingerprint(&self, tcx: Ctxt) -> Fingerprint { | |
127 | let mut hcx = tcx.create_stable_hashing_context(); | |
128 | let mut hasher = StableHasher::new(); | |
129 | ||
130 | self.hash_stable(&mut hcx, &mut hasher); | |
131 | ||
132 | hasher.finish() | |
133 | } | |
134 | ||
135 | default fn to_debug_str(&self, _: Ctxt) -> String { | |
136 | format!("{:?}", *self) | |
137 | } | |
138 | ||
139 | default fn recover(_: Ctxt, _: &DepNode<Ctxt::DepKind>) -> Option<Self> { | |
140 | None | |
141 | } | |
142 | } | |
143 | ||
f9f354fc XL |
144 | impl<Ctxt: DepContext> DepNodeParams<Ctxt> for () { |
145 | fn to_fingerprint(&self, _: Ctxt) -> Fingerprint { | |
146 | Fingerprint::ZERO | |
147 | } | |
148 | } | |
149 | ||
ba9703b0 XL |
150 | /// A "work product" corresponds to a `.o` (or other) file that we |
151 | /// save in between runs. These IDs do not have a `DefId` but rather | |
152 | /// some independent path or string that persists between runs without | |
153 | /// the need to be mapped or unmapped. (This ensures we can serialize | |
154 | /// them even in the absence of a tcx.) | |
3dfed10e XL |
155 | #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] |
156 | #[derive(Encodable, Decodable)] | |
ba9703b0 XL |
157 | pub struct WorkProductId { |
158 | hash: Fingerprint, | |
159 | } | |
160 | ||
161 | impl WorkProductId { | |
162 | pub fn from_cgu_name(cgu_name: &str) -> WorkProductId { | |
163 | let mut hasher = StableHasher::new(); | |
164 | cgu_name.len().hash(&mut hasher); | |
165 | cgu_name.hash(&mut hasher); | |
166 | WorkProductId { hash: hasher.finish() } | |
167 | } | |
168 | ||
169 | pub fn from_fingerprint(fingerprint: Fingerprint) -> WorkProductId { | |
170 | WorkProductId { hash: fingerprint } | |
171 | } | |
172 | } | |
173 | ||
174 | impl<HCX> HashStable<HCX> for WorkProductId { | |
175 | #[inline] | |
176 | fn hash_stable(&self, hcx: &mut HCX, hasher: &mut StableHasher) { | |
177 | self.hash.hash_stable(hcx, hasher) | |
178 | } | |
179 | } |