properly use and encode copy_span_{asc,des}

Author: Robbepop

crates/wasmi/src/engine/executor/handler/dispatch.rs

@@ -347,7 +347,8 @@ pub fn op_code_to_handler(code: OpCode) -> Handler {
         OpCode::Copy => exec::copy,
         OpCode::Copy32 => exec::copy32,
         OpCode::Copy64 => exec::copy64,
-        OpCode::CopySpan => exec::copy_span,
+        OpCode::CopySpanAsc => exec::copy_span_asc,
+        OpCode::CopySpanDes => exec::copy_span_des,
         // global
         OpCode::GlobalGet => exec::global_get,
         OpCode::GlobalSet => exec::global_set,

crates/wasmi/src/engine/executor/handler/exec.rs

@@ -18,7 +18,8 @@ use crate::{
         executor::handler::{
             state::DoneReason,
             utils::{
-                exec_copy_span,
+                exec_copy_span_asc,
+                exec_copy_span_des,
                 resolve_global,
                 resolve_indirect_func,
                 set_global,
@@ -80,7 +81,7 @@ pub fn consume_fuel(
     dispatch!(state, ip, sp, mem0, mem0_len, instance)
 }
 
-pub fn copy_span(
+pub fn copy_span_asc(
     state: &mut VmState,
     ip: Ip,
     sp: Sp,
@@ -90,13 +91,35 @@ pub fn copy_span(
 ) -> Done {
     let (
         ip,
-        crate::ir::decode::CopySpan {
+        crate::ir::decode::CopySpanAsc {
             results,
             values,
             len,
         },
     ) = unsafe { decode_op(ip) };
-    exec_copy_span(sp, results, values, len);
+    debug_assert!(results.head() <= values.head());
+    exec_copy_span_asc(sp, results, values, len);
+    dispatch!(state, ip, sp, mem0, mem0_len, instance)
+}
+
+pub fn copy_span_des(
+    state: &mut VmState,
+    ip: Ip,
+    sp: Sp,
+    mem0: *mut u8,
+    mem0_len: usize,
+    instance: NonNull<InstanceEntity>,
+) -> Done {
+    let (
+        ip,
+        crate::ir::decode::CopySpanDes {
+            results,
+            values,
+            len,
+        },
+    ) = unsafe { decode_op(ip) };
+    debug_assert!(results.head() >= values.head());
+    exec_copy_span_des(sp, results, values, len);
     dispatch!(state, ip, sp, mem0, mem0_len, instance)
 }
 
@@ -311,7 +334,7 @@ pub fn return_span(
     let dst = SlotSpan::new(Slot::from(0));
     let src = values.span();
     let len = values.len();
-    exec_copy_span(sp, dst, src, len);
+    exec_copy_span_asc(sp, dst, src, len);
     exec_return!(state, sp, mem0, mem0_len, instance)
 }
 

crates/wasmi/src/engine/executor/handler/utils.rs

@@ -141,7 +141,7 @@ macro_rules! exec_return {
     }};
 }
 
-pub fn exec_copy_span(sp: Sp, dst: SlotSpan, src: SlotSpan, len: u16) {
+pub fn exec_copy_span_asc(sp: Sp, dst: SlotSpan, src: SlotSpan, len: u16) {
     let dst = dst.iter(len);
     let src = src.iter(len);
     for (dst, src) in dst.into_iter().zip(src.into_iter()) {
@@ -150,6 +150,15 @@ pub fn exec_copy_span(sp: Sp, dst: SlotSpan, src: SlotSpan, len: u16) {
     }
 }
 
+pub fn exec_copy_span_des(sp: Sp, dst: SlotSpan, src: SlotSpan, len: u16) {
+    let dst = dst.iter(len);
+    let src = src.iter(len);
+    for (dst, src) in dst.into_iter().zip(src.into_iter()).rev() {
+        let value: u64 = get_value(src, sp);
+        set_value(sp, dst, value);
+    }
+}
+
 pub fn extract_mem0(
     store: &mut PrunedStore,
     instance: NonNull<InstanceEntity>,

crates/wasmi/src/engine/translator/func/mod.rs

@@ -495,9 +495,12 @@ impl FuncTranslator {
             // Case: results and values are equal and therefore the copy is a no-op
             return Ok(());
         }
-        debug_assert!(!SlotSpan::has_overlapping_copies(results, values, len));
+        let copy_span = match results.head() > values.head() {
+            true => Op::copy_span_des,
+            false => Op::copy_span_asc,
+        };
         self.instrs.encode(
-            Op::copy_span(results, values, len),
+            copy_span(results, values, len),
             consume_fuel_instr,
             |costs: &FuelCostsProvider| costs.fuel_for_copying_values(u64::from(len)),
         )?;