Skip to main content

rapx/vm/
exec.rs

1//! Execute retained path items in the symbolic VM.
2
3use 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    /// Execute all retained MIR items in path order.
15    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    /// Replay items while retaining a selected cleanup successor after a call.
28    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    /// Enter an inlined callee during path execution: save the caller context,
109    /// switch to the callee body, and bind the caller's argument locals to the
110    /// callee's parameters.
111    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        // Collect the caller argument fields from the saved map, so the callee's
168        // parameters inherit them (e.g. NonZero's non-zero inner value, and an
169        // iterator's `ptr`/`end_or_len`). A whole-place reborrow
170        // (`_7 = &mut (*_1)`) carries its referent's fields, so resolve it too;
171        // likewise a whole-place copy temporary (`_2 = copy _1`) that the
172        // optimizer inserted between the caller's argument and the inlined
173        // callee's parameter — follow both chains so the local that actually
174        // materialized the fields is found.
175        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(&param) {
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    /// Exit an inlined callee: capture the callee's return value, restore the
283    /// caller context, and write the return value to the caller's destination.
284    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    /// A `ManuallyDrop<Owner>` retained at return keeps its strong share alive.
359    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}