rapx/vm/mir_rules/call/
index.rs1use 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}