Skip to main content

rapx/vm/
range.rs

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        // A sub-slice has its own length. When it cannot be computed, it is
40        // unknown; it is never the length of the whole base slice.
41        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}