Skip to main content

rapx/vm/mir_rules/call/effect/
memory.rs

1use super::*;
2
3impl<'z3, 'tcx> VmExecutor<'z3, 'tcx> {
4    pub(super) fn apply_memory_effect(
5        &mut self,
6        effect: &CallEffect,
7        args: &[VmValue<'z3, 'tcx>],
8        dest: Local,
9    ) {
10        match effect {
11            CallEffect::LoadMemory { pointer_arg } => {
12                let value = args.get(*pointer_arg).and_then(|pointer| {
13                    let ty = self.body().local_decls[dest].ty;
14                    self.read_field_allocation(pointer, ty)
15                });
16                if let Some(mut value) = value {
17                    value.ty = self.body().local_decls[dest].ty;
18                    self.set_local(dest, value);
19                } else {
20                    self.set_opaque_intrinsic_result(dest);
21                }
22            }
23            CallEffect::StoreMemory {
24                pointer_arg,
25                value_arg,
26            } => {
27                let Some((pointer, value)) = args.get(*pointer_arg).zip(args.get(*value_arg))
28                else {
29                    self.record_unsupported("volatile_store arguments");
30                    return;
31                };
32                let mut value = value.clone();
33                value.facts.init = true;
34                if !self.write_through_pointer(pointer, Vec::new(), value) {
35                    self.record_unsupported("volatile_store target");
36                }
37            }
38            CallEffect::AtomicRmw { pointer_arg } => {
39                let Some(prov) = args
40                    .get(*pointer_arg)
41                    .and_then(|value| value.provenance.as_ref())
42                else {
43                    self.record_unsupported("atomic operation target");
44                    return;
45                };
46                self.forget_memory_values(prov.alloc_id);
47                let ty = self.body().local_decls[dest].ty;
48                let old = self.fresh_int("atomic_rmw_old");
49                self.set_local(dest, VmValue::new(old, ty));
50            }
51            CallEffect::CopyMemory {
52                source_arg,
53                destination_arg,
54                count_arg,
55            } => {
56                if let (Some(source), Some(target), Some(count)) = (
57                    args.get(*source_arg),
58                    args.get(*destination_arg),
59                    args.get(*count_arg),
60                ) {
61                    self.copy_memory_values(source, target, count);
62                }
63            }
64            CallEffect::SwapMemory {
65                left_arg,
66                right_arg,
67            } => {
68                let Some((left, right)) = args.get(*left_arg).zip(args.get(*right_arg)) else {
69                    self.record_unsupported_effect("SwapMemory arguments unavailable");
70                    return;
71                };
72                if !self.swap_memory_values(left, right) {
73                    self.record_unsupported_effect("SwapMemory target unsupported");
74                }
75            }
76            CallEffect::FillBytes {
77                pointer_arg,
78                byte_arg,
79                count_arg,
80            } => {
81                let (Some(pointer), Some(byte), Some(count)) = (
82                    args.get(*pointer_arg),
83                    args.get(*byte_arg),
84                    args.get(*count_arg),
85                ) else {
86                    self.record_unsupported_effect("FillBytes arguments unavailable");
87                    return;
88                };
89                let concrete_count = count.z3_term.simplify().as_u64();
90                if concrete_count == Some(0) {
91                    return;
92                }
93                let (Some(ty), Some(byte_value)) = (
94                    mir_utils::pointee_ty(pointer.ty),
95                    byte.z3_term.simplify().as_u64(),
96                ) else {
97                    self.record_unsupported_effect(
98                        "FillBytes pointee type or byte value unavailable",
99                    );
100                    return;
101                };
102                let local = self
103                    .find_local_by_address(&pointer.z3_term)
104                    .filter(|local| self.body().local_decls[*local].ty == ty);
105                let inline_target =
106                    self.path_state.inline
107                        .arg_referents
108                        .iter()
109                        .enumerate()
110                        .any(|(i, referent)| {
111                            referent.is_some()
112                                && self
113                                    .local_value(Local::from_usize(i + 1))
114                                    .is_some_and(|value| value.z3_term == pointer.z3_term)
115                        });
116                if concrete_count == Some(1)
117                    && byte_value <= u8::MAX as u64
118                    && self.fill_byte_array(pointer, byte_value)
119                {
120                    return;
121                }
122                if concrete_count != Some(1)
123                    || (local.is_none() && !inline_target)
124                    || !matches!(ty.kind(), TyKind::Int(_) | TyKind::Uint(_))
125                    || byte_value > u8::MAX as u64
126                {
127                    let allocation = pointer.provenance.as_ref().map(|provenance| {
128                        format!(
129                            "kind={:?}, element={:?}, size={:?}",
130                            self.alloc(provenance.alloc_id).kind,
131                            self.alloc(provenance.alloc_id).element_ty,
132                            self.allocation_size(provenance.alloc_id),
133                        )
134                    });
135                    self.record_unsupported_effect(&format!(
136                        "FillBytes target unsupported: count={concrete_count:?}, local={}, inline_target={inline_target}, pointee={ty:?}, byte={byte_value}, provenance={:?}, allocation={allocation:?}",
137                        local.is_some(),
138                        pointer.provenance,
139                    ));
140                    return;
141                }
142                let value_bits = if byte_value == 0 {
143                    0
144                } else {
145                    let size = self.size_of_ty(ty);
146                    if !matches!(ty.kind(), TyKind::Uint(_)) || size == 0 || size > 8 {
147                        self.record_unsupported_effect(&format!(
148                            "FillBytes nonzero fill unsupported: pointee={ty:?}, size={size}"
149                        ));
150                        return;
151                    }
152                    (0..size).fold(0_u64, |bits, index| bits | (byte_value << (8 * index)))
153                };
154                let mut value = VmValue::new(Int::from_u64(self.z3_ctx, value_bits), ty);
155                value.facts.init = true;
156                self.write_through_pointer(pointer, Vec::new(), value);
157                if let Some(local) = local
158                    && let Some(alloc_id) = self.path_state.current_frame.local_alloc.get(&local).copied()
159                {
160                    self.content_mut(alloc_id).facts.initialized = true;
161                }
162            }
163            _ => unreachable!("non-memory call effect"),
164        }
165    }
166}