feat: local call/return detection with context-sensitive resolution

crates/revmc/src/bytecode/mod.rs

@@ -426,6 +426,85 @@ impl<'a> Bytecode<'a> {
         self.code.get(start).copied().unwrap_or(0)
     }
 
+    /// Applies stack-shuffling opcodes (POP, DUP, SWAP, DUPN, SWAPN, EXCHANGE) to an abstract
+    /// stack.
+    ///
+    /// Returns `Some(true)` if the opcode was handled, `Some(false)` on invalid stack underflow
+    /// or decode failure, or `None` if the opcode is not a stack-shuffling instruction (caller
+    /// handles PUSH and fallback).
+    ///
+    /// `unknown` is pushed when DUPN/SWAPN/EXCHANGE access a slot beyond the tracked stack depth.
+    pub(crate) fn apply_stack_shuffle<T: Copy>(
+        &self,
+        inst: &InstData,
+        stack: &mut Vec<T>,
+        unknown: T,
+    ) -> Option<bool> {
+        match inst.opcode {
+            op::POP => {
+                if stack.pop().is_none() {
+                    return Some(false);
+                }
+            }
+            op::DUP1..=op::DUP16 => {
+                let depth = (inst.opcode - op::DUP1 + 1) as usize;
+                if stack.len() < depth {
+                    return Some(false);
+                }
+                stack.push(stack[stack.len() - depth]);
+            }
+            op::SWAP1..=op::SWAP16 => {
+                let depth = (inst.opcode - op::SWAP1 + 1) as usize;
+                let len = stack.len();
+                if len < depth + 1 {
+                    return Some(false);
+                }
+                stack.swap(len - 1, len - 1 - depth);
+            }
+            op::DUPN => {
+                let Some(n) = crate::decode_single(self.get_u8_imm(inst)) else {
+                    return Some(false);
+                };
+                let n = n as usize;
+                if stack.len() < n {
+                    stack.push(unknown);
+                } else {
+                    stack.push(stack[stack.len() - n]);
+                }
+            }
+            op::SWAPN => {
+                let Some(n) = crate::decode_single(self.get_u8_imm(inst)) else {
+                    return Some(false);
+                };
+                let n = n as usize;
+                let len = stack.len();
+                if len < n + 1 {
+                    if let Some(tos) = stack.last_mut() {
+                        *tos = unknown;
+                    }
+                } else {
+                    stack.swap(len - 1, len - 1 - n);
+                }
+            }
+            op::EXCHANGE => {
+                let Some((n, m)) = crate::decode_pair(self.get_u8_imm(inst)) else {
+                    return Some(false);
+                };
+                let (n, m) = (n as usize, m as usize);
+                let len = stack.len();
+                if len < m + 1 {
+                    if len > n {
+                        stack[len - 1 - n] = unknown;
+                    }
+                } else {
+                    stack.swap(len - 1 - n, len - 1 - m);
+                }
+            }
+            _ => return None,
+        }
+        Some(true)
+    }
+
     /// Returns `true` if the given program counter is a valid jump destination.
     fn is_valid_jump(&self, pc: usize) -> bool {
         self.jumpdests.get(pc).as_deref().copied() == Some(true)