Skip to main content

rapx/vm/mir_rules/call/
index.rs

1use rustc_middle::{mir::Local, ty::TyKind};
2use z3::ast::Int;
3
4use crate::def_ids::lang_api::{self, LangItem};
5
6use super::super::super::state::{VmExecutor, VmValue};
7
8pub(super) struct BuiltinIndexPlan<'z3, 'tcx> {
9    base: VmValue<'z3, 'tcx>,
10    index: VmValue<'z3, 'tcx>,
11    index_local: Local,
12    start: Int<'z3>,
13    base_len: Int<'z3>,
14    output_len: Option<Int<'z3>>,
15}
16
17impl<'z3, 'tcx> VmExecutor<'z3, 'tcx> {
18    pub(super) fn prepare_builtin_index(
19        &self,
20        callee: Option<rustc_hir::def_id::DefId>,
21        args: &[VmValue<'z3, 'tcx>],
22        arg_locals: &[Option<Local>],
23        dest: Local,
24    ) -> Option<BuiltinIndexPlan<'z3, 'tcx>> {
25        let Some(callee) = callee else {
26            return None;
27        };
28        let Some(trait_id) = self.tcx.trait_of_assoc(callee) else {
29            return None;
30        };
31        if !lang_api::matches(self.tcx, trait_id, LangItem::Index)
32            && !lang_api::matches(self.tcx, trait_id, LangItem::IndexMut)
33        {
34            return None;
35        }
36        let [base, index] = args else {
37            return None;
38        };
39        let TyKind::Ref(_, base_pointee, _) = base.ty.kind() else {
40            return None;
41        };
42        let (TyKind::Array(_, _) | TyKind::Slice(_)) = base_pointee.kind() else {
43            return None;
44        };
45        let TyKind::Ref(..) = self.body().local_decls[dest].ty.kind() else {
46            return None;
47        };
48        let is_scalar = matches!(
49            index.ty.kind(),
50            TyKind::Uint(rustc_middle::ty::UintTy::Usize)
51        );
52        let Some(index_local) = arg_locals.get(1).copied().flatten() else {
53            return None;
54        };
55        let Some(start) = self.slice_index_start(index, index_local) else {
56            return None;
57        };
58        let Some(base_len) = self.slice_len_from_value(base) else {
59            return None;
60        };
61        let output_len = if is_scalar {
62            None
63        } else {
64            let Some(len) = self.slice_index_output_len(base, index, index_local) else {
65                return None;
66            };
67            Some(len)
68        };
69        Some(BuiltinIndexPlan {
70            base: base.clone(),
71            index: index.clone(),
72            index_local,
73            start,
74            base_len,
75            output_len,
76        })
77    }
78
79    pub(super) fn apply_builtin_index(&mut self, plan: BuiltinIndexPlan<'z3, 'tcx>, dest: Local) {
80        let BuiltinIndexPlan {
81            base,
82            index,
83            index_local,
84            start,
85            base_len,
86            output_len,
87        } = plan;
88        let zero = Int::from_u64(self.z3_ctx, 0);
89        self.path_state.constraints.assertions.push(start.ge(&zero));
90        if let Some(len) = output_len {
91            self.path_state.constraints.assertions.push(len.ge(&zero));
92            self.path_state.constraints
93                .assertions
94                .push((&start + &len).le(&base_len));
95            self.apply_slice_offset(dest, &base, &index, index_local);
96            self.materialize_slice_ref_return(dest);
97        } else {
98            self.path_state.constraints.assertions.push(start.lt(&base_len));
99            self.apply_slice_offset(dest, &base, &index, index_local);
100        }
101    }
102}