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