1use rustc_hir::def_id::DefId;
4use rustc_middle::mir::{Local, TerminatorKind, UnwindAction};
5use rustc_middle::ty::TyKind;
6use z3::ast::Int;
7
8use crate::{analysis::path::CallArg, compat::FxHashSet, vm::RelevantItem};
9
10use super::diagnostics::{ActiveMirItem, ActiveMirLocation};
11use super::state::{ValueSource, VmExecutor, VmValue};
12
13impl<'z3, 'tcx> VmExecutor<'z3, 'tcx> {
14 pub(crate) fn execute_items(mut self, items: &[RelevantItem<'tcx>]) -> Vec<Self> {
16 self.init_parameters();
17 Self::execute_items_after(vec![self], items)
18 }
19
20 pub(crate) fn execute_items_after(
21 states: Vec<Self>,
22 items: &[RelevantItem<'tcx>],
23 ) -> Vec<Self> {
24 Self::execute_items_after_inner(states, items, false)
25 }
26
27 pub(crate) fn execute_items_after_with_cleanup(states: Vec<Self>, items: &[RelevantItem<'tcx>]) -> Vec<Self> {
29 Self::execute_items_after_inner(states, items, true)
30 }
31
32 fn execute_items_after_inner(
33 mut states: Vec<Self>,
34 items: &[RelevantItem<'tcx>],
35 retain_cleanup: bool,
36 ) -> Vec<Self> {
37 for item in items {
38 let mut next = Vec::new();
39 for mut state in states {
40 let viable = if state.path_state.diagnostics.is_unsupported() {
41 true
42 } else {
43 let viable = state.execute_item(item, retain_cleanup);
44 next.extend(std::mem::take(&mut state.path_state.inline.pending_states).into_iter().map(|state| *state));
45 viable
46 };
47 if viable {
48 next.push(state);
49 }
50 }
51 states = next;
52 }
53 states
54 }
55
56 fn execute_item(&mut self, item: &RelevantItem<'tcx>, retain_cleanup: bool) -> bool {
57 match item {
58 RelevantItem::Statement {
59 def_id,
60 block,
61 stmt_index,
62 ..
63 } => {
64 let body = self.body_for(*def_id);
65 let statement = &body.basic_blocks[*block].statements[*stmt_index];
66 self.path_state.diagnostics.active_mir = Some(ActiveMirLocation {
67 def_id: *def_id,
68 block: block.as_usize(),
69 item: ActiveMirItem::Statement(*stmt_index),
70 span: statement.source_info.span,
71 });
72 crate::vm::mir_rules::exec_statement(self, statement);
73 true
74 }
75 RelevantItem::Terminator {
76 def_id,
77 block,
78 switch_succ,
79 ..
80 } => {
81 let body = self.body_for(*def_id);
82 let terminator = body.basic_blocks[*block].terminator();
83 self.path_state.diagnostics.active_mir = Some(ActiveMirLocation {
84 def_id: *def_id,
85 block: block.as_usize(),
86 item: ActiveMirItem::Terminator,
87 span: terminator.source_info.span,
88 });
89 let viable =
90 crate::vm::mir_rules::exec_terminator(self, terminator, *switch_succ).continues();
91 viable || (retain_cleanup
92 && matches!(&terminator.kind, TerminatorKind::Call { unwind: UnwindAction::Cleanup(target), .. } if Some(*target) == *switch_succ)
93 )
94 }
95 RelevantItem::CalleeEntry { callee, body, args } => {
96 self.path_state.diagnostics.active_mir = None;
97 self.handle_callee_entry(*callee, *body, args);
98 true
99 }
100 RelevantItem::CalleeExit { dest } => {
101 self.path_state.diagnostics.active_mir = None;
102 self.handle_callee_exit(*dest);
103 true
104 }
105 }
106 }
107
108 fn handle_callee_entry(
112 &mut self,
113 callee: DefId,
114 body: Option<&'tcx rustc_middle::mir::Body<'tcx>>,
115 args: &[CallArg],
116 ) {
117 let param_count = body
118 .map(|body| body.arg_count)
119 .unwrap_or_else(|| self.tcx.optimized_mir(callee).arg_count);
120 let param_sources: Vec<Option<Local>> = (1..=param_count)
121 .map(|param| match args.get(param - 1) {
122 Some(CallArg::Local(local)) => Some(Local::from_usize(*local)),
123 _ => None,
124 })
125 .collect();
126 let arg_referents: Vec<Option<Local>> = param_sources
127 .iter()
128 .map(|arg| {
129 let arg_local = (*arg)?;
130 self.local_value(arg_local).and_then(|value| {
131 let address_referent = self.find_local_by_address(&value.z3_term);
132 let borrow_referent = self.find_whole_borrow_referent(arg_local);
133 let referent = if address_referent == Some(arg_local) {
134 borrow_referent.or(address_referent)
135 } else {
136 address_referent.or(borrow_referent)
137 };
138 referent
139 .or_else(|| {
140 self.find_copy_root(arg_local).filter(|root| {
141 self.local_value(*root).is_some_and(|source| {
142 value
143 .provenance_alloc_id()
144 .is_some_and(|id| source.provenance_alloc_id() == Some(id))
145 }) && self.field_value(*root, &[0]).is_some()
146 })
147 })
148 .or_else(|| {
149 let outer = arg_local
150 .as_usize()
151 .checked_sub(1)
152 .and_then(|index| self.path_state.inline.arg_referents.get(index))
153 .copied()
154 .flatten()?;
155 let parent_alloc =
156 self.path_state.caller_frames.last()?.frame.local_alloc.get(&outer)?;
157 (value.provenance_alloc_id() == Some(*parent_alloc))
158 .then_some(arg_local)
159 })
160 })
161 })
162 .collect();
163 let saved_referents = std::mem::replace(&mut self.path_state.inline.arg_referents, arg_referents);
164 let saved_writes = std::mem::take(&mut self.path_state.inline.deferred_field_writes);
165 let frame = self.enter_frame(callee, body);
166
167 let mut arg_fields: Vec<(usize, Vec<usize>, VmValue<'z3, 'tcx>)> = Vec::new();
176 let mut bound_fields: FxHashSet<(usize, Vec<usize>)> = FxHashSet::default();
177 for (i, caller_local) in param_sources.iter().enumerate() {
178 let Some(caller_local) = caller_local else {
179 continue;
180 };
181 let caller_local = *caller_local;
182 let mut source_locals: Vec<(Local, Vec<usize>)> = Vec::new();
183 let mut seen: FxHashSet<(Local, Vec<usize>)> = FxHashSet::default();
184 let mut stack = vec![(caller_local, Vec::new())];
185 while let Some((cur, prefix)) = stack.pop() {
186 if !seen.insert((cur, prefix.clone())) {
187 continue;
188 }
189 source_locals.push((cur, prefix.clone()));
190 if let Some(r) = self.find_whole_borrow_referent(cur) {
191 stack.push((r, prefix.clone()));
192 }
193 if let Some((r, fields)) = self.find_field_reborrow_referent(cur) {
194 let mut new_prefix = prefix.clone();
195 new_prefix.extend(fields);
196 stack.push((r, new_prefix));
197 }
198 if let Some(c) = self.find_copy_root(cur) {
199 stack.push((c, prefix.clone()));
200 }
201 }
202 for (src, prefix) in source_locals {
203 let keys: Vec<Vec<usize>> = self
204 .frame_field_paths(&frame, src)
205 .into_iter()
206 .filter(|f| {
207 prefix.is_empty()
208 || (f.len() >= prefix.len() && f[..prefix.len()] == prefix[..])
209 })
210 .collect();
211 for fields in keys {
212 if let Some(fv) = self.frame_field_value(&frame, src, &fields).cloned() {
213 let stripped = if prefix.is_empty() {
214 fields
215 } else {
216 fields[prefix.len()..].to_vec()
217 };
218 if bound_fields.insert((i + 1, stripped.clone())) {
219 arg_fields.push((i + 1, stripped, fv));
220 }
221 }
222 }
223 }
224 }
225
226 for (i, arg) in param_sources.iter().enumerate() {
227 if let Some(v) = arg
228 .and_then(|local| self.frame_local_value(&frame, local))
229 .cloned()
230 {
231 let inner_uninit = arg
232 .and_then(|local| frame.local_alloc.get(&local))
233 .is_some_and(|id| self.content(*id).facts.inner_uninit);
234 let param = Local::from_usize(i + 1);
235 self.set_local(param, v);
236 if inner_uninit && let Some(&id) = self.path_state.current_frame.local_alloc.get(¶m) {
237 self.content_mut(id).facts.inner_uninit = true;
238 }
239 }
240 }
241
242 for (index, arg) in args.iter().enumerate().take(param_count) {
243 let local = Local::from_usize(index + 1);
244 let ty = self.body().local_decls[local].ty;
245 let (term, source) = match arg {
246 CallArg::Local(_) => continue,
247 CallArg::Literal(value) => {
248 let width = self.size_of_ty(ty).saturating_mul(8);
249 let text = if matches!(ty.kind(), rustc_middle::ty::TyKind::Int(_))
250 && (1..=128).contains(&width)
251 {
252 let shift = 128 - width as u32;
253 (((*value << shift) as i128) >> shift).to_string()
254 } else {
255 value.to_string()
256 };
257 (
258 Int::from_str(self.z3_ctx, &text).expect("valid integer literal"),
259 ValueSource::CallsiteConst,
260 )
261 }
262 CallArg::Symbol(text) => (self.symbolic_const_term_text(text), ValueSource::None),
263 CallArg::FieldOffset => (self.fresh_int("field_offset"), ValueSource::FieldOffset),
264 CallArg::Opaque => (self.fresh_int("opaque_call_arg"), ValueSource::None),
265 };
266 let mut value = VmValue::new(term, ty);
267 value.source = source;
268 self.set_local(local, value);
269 }
270
271 for (callee_param, fields, fv) in arg_fields {
272 self.set_field_value(Local::from_usize(callee_param), fields, fv);
273 }
274 self.path_state.caller_frames.push(super::state::SavedCallerFrame {
275 frame,
276 postcondition_args: param_sources,
277 arg_referents: saved_referents,
278 deferred_writes: saved_writes,
279 });
280 }
281
282 fn handle_callee_exit(&mut self, dest: usize) {
285 let callee = self.path_state.current_frame.current_def_id;
286 self.recover_leaked_owner_shares(callee);
287 let ret = self.local_value(Local::from_usize(0)).cloned();
288 let ret_inner_uninit = self.path_state
289 .current_frame
290 .local_alloc
291 .get(&Local::from_usize(0))
292 .is_some_and(|id| self.content(*id).facts.inner_uninit);
293 let ret_fields: Vec<(Vec<usize>, VmValue<'z3, 'tcx>)> = self
294 .field_paths(Local::from_usize(0))
295 .into_iter()
296 .filter_map(|f| {
297 self.field_value(Local::from_usize(0), &f)
298 .cloned()
299 .map(|v| (f, v))
300 })
301 .collect();
302 let writes = std::mem::take(&mut self.path_state.inline.deferred_field_writes);
303 let postcondition_args = match self.path_state.caller_frames.pop() {
304 Some(saved) => {
305 self.restore_frame(saved.frame);
306 self.path_state.inline.arg_referents = saved.arg_referents;
307 self.path_state.inline.deferred_field_writes = saved.deferred_writes;
308 Some(saved.postcondition_args)
309 }
310 None => {
311 self.path_state.inline.arg_referents.clear();
312 None
313 }
314 };
315 self.replay_deferred_writes(writes);
316 if let Some(mut v) = ret.clone() {
317 let dest_ty = self.body().local_decls[Local::from_usize(dest)].ty;
318 v.ty = dest_ty;
319 let at_base = v
320 .provenance
321 .as_ref()
322 .is_some_and(|p| p.offset.as_u64() == Some(0));
323 if at_base {
324 v.facts.non_null = true;
325 }
326 self.set_local(Local::from_usize(dest), v);
327 if let Some(owner) =
328 crate::analysis::alias::shared_owner::shared_raw_owner_type(self.tcx, callee)
329 {
330 self.begin_ownership_transfer(Local::from_usize(dest), owner);
331 }
332 if ret_inner_uninit
333 && let Some(&dest_id) = self.path_state.current_frame.local_alloc.get(&Local::from_usize(dest))
334 {
335 self.content_mut(dest_id).facts.inner_uninit = true;
336 }
337 if let Some(dest_alloc_id) = self.path_state
338 .current_frame
339 .local_alloc
340 .get(&Local::from_usize(dest))
341 .copied()
342 {
343 self.content_mut(dest_alloc_id).facts.initialized = true;
344 }
345 }
346 for (fields, fv) in ret_fields {
347 self.set_field_value(Local::from_usize(dest), fields, fv);
348 }
349 self.materialize_slice_ref_return(Local::from_usize(dest));
350 if let Some(args) = postcondition_args
351 && self.local_value(Local::from_usize(dest)).is_some()
352 {
353 self.assert_call_postconditions(callee, &args, Local::from_usize(dest));
354 self.assert_call_result_invariants(Local::from_usize(dest));
355 }
356 }
357
358 pub(super) fn recover_leaked_owner_shares(&mut self, callee: DefId) {
360 let raw_args: Vec<_> = crate::contract::json::ref_count_share_arg_indices(self.tcx, callee)
361 .into_iter()
362 .map(|index| Local::from_usize(index + 1))
363 .filter_map(|local| self.local_value(local).cloned())
364 .collect();
365 if raw_args.is_empty() {
366 return;
367 }
368 let arg_count = self.body().arg_count;
369 let mut grants = Vec::new();
370 for (local, decl) in self.body().local_decls.iter_enumerated() {
371 if local.as_usize() <= arg_count {
372 continue;
373 }
374 let TyKind::Adt(wrapper, args) = decl.ty.kind() else {
375 continue;
376 };
377 if !self.tcx.is_lang_item(
378 wrapper.did(),
379 crate::def_ids::lang_api::LangItem::ManuallyDrop,
380 ) {
381 continue;
382 }
383 let Some(owner) = args
384 .first()
385 .and_then(|arg| arg.as_type())
386 .and_then(|ty| ty.ty_adt_def())
387 else {
388 continue;
389 };
390 let Some(alloc) = self
391 .owner_ptr_field(local)
392 .and_then(VmValue::provenance_alloc_id)
393 else {
394 continue;
395 };
396 let root = self.root_alloc(alloc);
397 if let Some(raw) = raw_args.iter().find(|raw| {
398 raw.provenance_alloc_id().is_some_and(|id| self.root_alloc(id) == root)
399 && self.ownership_share(raw, owner.did()).is_some()
400 }) {
401 grants.push((raw.clone(), owner.did()));
402 }
403 }
404 for (raw, owner) in grants {
405 self.grant_ownership_share(&raw, owner);
406 }
407 }
408}