1use rustc_middle::{mir::Local, ty::TyKind};
2use z3::ast::Int;
3
4use crate::def_ids::type_ids;
5use crate::def_ids::lang_api::{self, LangItem};
6use crate::util::mir_utils;
7
8use super::state::{ValueSource, VmExecutor, VmValue};
9
10impl<'z3, 'tcx> VmExecutor<'z3, 'tcx> {
11 pub(crate) fn apply_slice_offset(
12 &mut self,
13 dest: Local,
14 base: &VmValue<'z3, 'tcx>,
15 index: &VmValue<'z3, 'tcx>,
16 index_local: Local,
17 ) -> bool {
18 let dest_ty = self.body().local_decls[dest].ty;
19 let is_slice = mir_utils::pointee_ty(dest_ty)
20 .is_some_and(|ty| matches!(ty.kind(), TyKind::Slice(_) | TyKind::Str));
21 let start = if let Some(start) = self.slice_index_start(index, index_local) {
22 start
23 } else {
24 let Some(len) = self.slice_len_from_value(base) else {
25 return false;
26 };
27 let start = self.fresh_int("slice_offset_index");
28 let zero = Int::from_u64(self.z3_ctx, 0);
29 self.path_state.constraints.assertions.push(start.ge(&zero));
30 self.path_state.constraints.assertions.push(if is_slice {
31 start.le(&len)
32 } else {
33 start.lt(&len)
34 });
35 start
36 };
37 let offset = VmValue::new(start, self.tcx.types.usize);
38 self.apply_pointer_add(dest, base, &offset, None, base.facts.in_bounds);
39 if is_slice && let Some(mut value) = self.local_value(dest).cloned() {
42 let len = self
43 .slice_index_output_len(base, index, index_local)
44 .unwrap_or_else(|| self.fresh_int("slice_offset_len"));
45 value.source = ValueSource::SliceLen(len);
46 self.set_local(dest, value);
47 }
48 true
49 }
50
51 pub(crate) fn slice_index_start(
52 &self,
53 index: &VmValue<'z3, 'tcx>,
54 index_local: Local,
55 ) -> Option<Int<'z3>> {
56 let start_field = || {
57 self.field_value(index_local, &[0])
58 .map(|value| value.z3_term.clone())
59 };
60 match index.ty.kind() {
61 TyKind::Uint(rustc_middle::ty::UintTy::Usize) => Some(index.z3_term.clone()),
62 TyKind::Adt(def, _) => match mir_utils::range_kind(self.tcx, def.did()) {
63 mir_utils::RangeKind::RangeTo => Some(Int::from_u64(self.z3_ctx, 0)),
64 mir_utils::RangeKind::RangeFrom
65 | mir_utils::RangeKind::Range
66 | mir_utils::RangeKind::RangeInclusive => start_field(),
67 mir_utils::RangeKind::Other => {
68 if type_ids::is_index_range(def.did()) {
69 start_field()
70 } else {
71 (lang_api::matches(self.tcx, def.did(), LangItem::RangeToInclusive)
72 || lang_api::matches(self.tcx, def.did(), LangItem::RangeFull))
73 .then(|| Int::from_u64(self.z3_ctx, 0))
74 }
75 }
76 },
77 _ => None,
78 }
79 }
80
81 pub(crate) fn slice_index_output_len(
82 &self,
83 base: &VmValue<'z3, 'tcx>,
84 index: &VmValue<'z3, 'tcx>,
85 index_local: Local,
86 ) -> Option<Int<'z3>> {
87 let TyKind::Adt(def, _) = index.ty.kind() else {
88 return None;
89 };
90 let start = self.slice_index_start(index, index_local)?;
91 let one = Int::from_u64(self.z3_ctx, 1);
92 let end = match mir_utils::range_kind(self.tcx, def.did()) {
93 mir_utils::RangeKind::Range => self.field_value(index_local, &[1])?.z3_term.clone(),
94 mir_utils::RangeKind::RangeInclusive => {
95 self.field_value(index_local, &[1])?.z3_term.clone() + &one
96 }
97 mir_utils::RangeKind::RangeTo => self.field_value(index_local, &[0])?.z3_term.clone(),
98 mir_utils::RangeKind::RangeFrom => self.slice_len_from_value(base)?,
99 mir_utils::RangeKind::Other if type_ids::is_index_range(def.did()) => {
100 self.field_value(index_local, &[1])?.z3_term.clone()
101 }
102 mir_utils::RangeKind::Other => {
103 if lang_api::matches(self.tcx, def.did(), LangItem::RangeToInclusive) {
104 self.field_value(index_local, &[0])?.z3_term.clone() + &one
105 } else if lang_api::matches(self.tcx, def.did(), LangItem::RangeFull) {
106 self.slice_len_from_value(base)?
107 } else {
108 return None;
109 }
110 }
111 };
112 Some(end - &start)
113 }
114}