Feat: Implement Sign Extension Operators (Issue #55)

crates/spacewasm_util/src/debug.rs

@@ -195,6 +195,11 @@ impl<'a, ST: OutputStream, S, E, T: BaseVisitor<State = S, Error = E>> BaseVisit
 
     // Numeric instructions - conversions
     visit_fn!(i32_wrap_i64);
+    visit_fn!(i32_extend8_s);
+    visit_fn!(i32_extend16_s);
+    visit_fn!(i64_extend8_s);
+    visit_fn!(i64_extend16_s);
+    visit_fn!(i64_extend32_s);
     visit_fn!(i32_trunc_f32_s);
     visit_fn!(i32_trunc_f32_u);
     visit_fn!(i32_trunc_f64_s);

crates/spacewasm_util/src/trace.rs

@@ -318,6 +318,11 @@ impl<'a, 'store, T: BaseVisitor<State = InterpreterState<'store>, Error = E>, E>
 
     // Numeric instructions - conversions
     trace_visit_fn!(i32_wrap_i64);
+    trace_visit_fn!(i32_extend8_s);
+    trace_visit_fn!(i32_extend16_s);
+    trace_visit_fn!(i64_extend8_s);
+    trace_visit_fn!(i64_extend16_s);
+    trace_visit_fn!(i64_extend32_s);
     trace_visit_fn!(i32_trunc_f32_s);
     trace_visit_fn!(i32_trunc_f32_u);
     trace_visit_fn!(i32_trunc_f64_s);

src/code.rs

@@ -410,6 +410,11 @@ impl<'wasm> Reader<'wasm> {
 
                 // Numeric instructions - conversions
                 I32_WRAP_I64 => instruction!(i32_wrap_i64),
+                I32_EXTEND8_S => instruction!(i32_extend8_s),
+                I32_EXTEND16_S => instruction!(i32_extend16_s),
+                I64_EXTEND8_S => instruction!(i64_extend8_s),
+                I64_EXTEND16_S => instruction!(i64_extend16_s),
+                I64_EXTEND32_S => instruction!(i64_extend32_s),
                 I32_TRUNC_F32_S => instruction!(i32_trunc_f32_s),
                 I32_TRUNC_F32_U => instruction!(i32_trunc_f32_u),
                 I32_TRUNC_F64_S => instruction!(i32_trunc_f64_s),

src/compiler.rs

@@ -594,6 +594,11 @@ impl<'a, const MAX_CODE_PAGES: usize, const MAX_CONTROL_FRAMES: usize, const MAX
     instruction!(f64_copysign, F64_COPYSIGN, (F64 F64) -> (F64));
 
     instruction!(i32_wrap_i64, I32_WRAP_I64, (I64) -> (I32));
+    instruction!(i32_extend8_s, I32_EXTEND8_S, (I32) -> (I32));
+    instruction!(i32_extend16_s, I32_EXTEND16_S, (I32) -> (I32));
+    instruction!(i64_extend8_s, I64_EXTEND8_S, (I64) -> (I64));
+    instruction!(i64_extend16_s, I64_EXTEND16_S, (I64) -> (I64));
+    instruction!(i64_extend32_s, I64_EXTEND32_S, (I64) -> (I64));
     instruction!(i32_trunc_f32_s, I32_TRUNC_F32_S, (F32) -> (I32));
     instruction!(i32_trunc_f32_u, I32_TRUNC_F32_U, (F32) -> (I32));
     instruction!(i32_trunc_f64_s, I32_TRUNC_F64_S, (F64) -> (I32));
@@ -614,4 +619,9 @@ impl<'a, const MAX_CODE_PAGES: usize, const MAX_CONTROL_FRAMES: usize, const MAX
     instruction!(f64_convert_i64_s, F64_CONVERT_I64_S, (I64) -> (F64));
     instruction!(f64_convert_i64_u, F64_CONVERT_I64_U, (I64) -> (F64));
     instruction!(f64_promote_f32, F64_PROMOTE_F32, (F32) -> (F64));
+    instruction!(i32_extend8_s, I32_EXTEND8_S, (I32) -> (I32));
+    instruction!(i32_extend16_s, I32_EXTEND16_S, (I32) -> (I32));
+    instruction!(i64_extend8_s, I64_EXTEND8_S, (I64) -> (I64));
+    instruction!(i64_extend16_s, I64_EXTEND16_S, (I64) -> (I64));
+    instruction!(i64_extend32_s, I64_EXTEND32_S, (I64) -> (I64));
 }

src/constant.rs

@@ -232,6 +232,11 @@ impl<'a> BaseVisitor for ConstantCompiler<'a> {
 
     // Numeric instructions - conversions
     invalid_constant_fn!(i32_wrap_i64);
+    invalid_constant_fn!(i32_extend8_s);
+    invalid_constant_fn!(i32_extend16_s);
+    invalid_constant_fn!(i64_extend8_s);
+    invalid_constant_fn!(i64_extend16_s);
+    invalid_constant_fn!(i64_extend32_s);
     invalid_constant_fn!(i32_trunc_f32_s);
     invalid_constant_fn!(i32_trunc_f32_u);
     invalid_constant_fn!(i32_trunc_f64_s);

src/interpreter.rs

@@ -1109,6 +1109,37 @@ impl<'store> BaseVisitor for Interpreter<'store> {
         Ok(())
     }
 
+    fn i32_extend8_s(&self, state: &mut Self::State) -> Result<(), Self::Error> {
+        let i = state.stack.read_u32(state.sp - 1) as i8 as i32 as u32;
+        state.stack.write_u32(state.sp - 1, i);
+        Ok(())
+    }
+
+    fn i32_extend16_s(&self, state: &mut Self::State) -> Result<(), Self::Error> {
+        let i = state.stack.read_u32(state.sp - 1) as i16 as i32 as u32;
+        state.stack.write_u32(state.sp - 1, i);
+        Ok(())
+    }
+
+    fn i64_extend8_s(&self, state: &mut Self::State) -> Result<(), Self::Error> {
+        let i = state.stack.read_u64(state.sp - 2) as i8 as i64 as u64;
+        state.stack.write_u64(state.sp - 2, i);
+        Ok(())
+    }
+
+    fn i64_extend16_s(&self, state: &mut Self::State) -> Result<(), Self::Error> {
+        let i = state.stack.read_u64(state.sp - 2) as i16 as i64 as u64;
+        state.stack.write_u64(state.sp - 2, i);
+        Ok(())
+    }
+
+    fn i64_extend32_s(&self, state: &mut Self::State) -> Result<(), Self::Error> {
+        let i = state.stack.read_u64(state.sp - 2) as i32 as i64 as u64;
+        state.stack.write_u64(state.sp - 2, i);
+        Ok(())
+    }
+
+
     fn i64_extend_i32_u(&self, state: &mut Self::State) -> Result<(), Self::Error> {
         // Low word is already in place at [sp-1]
         // Just add high word as 0 for unsigned extension

src/interpreter_tests.rs

@@ -808,6 +808,74 @@ mod tests {
         });
     }
 
+    #[test]
+    fn test_i32_extend8_s() {
+        with_test_context(|state| {
+            let interpreter = Interpreter::default();
+            state.stack.write_u32(0, 0x000000FF);
+            state.sp = 1;
+            interpreter.i32_extend8_s(state).unwrap();
+            assert_eq!(state.sp, 1);
+            assert_eq!(state.stack.read_u32(0), 0xFFFFFFFF); // -1
+
+            state.stack.write_u32(0, 0x0000007F);
+            interpreter.i32_extend8_s(state).unwrap();
+            assert_eq!(state.stack.read_u32(0), 0x0000007F); // 127
+        });
+    }
+
+    #[test]
+    fn test_i64_extend8_s() {
+        with_test_context(|state| {
+            let interpreter = Interpreter::default();
+            state.stack.write_u64(0, 0x00000000000000FF);
+            state.sp = 2;
+            interpreter.i64_extend8_s(state).unwrap();
+            assert_eq!(state.sp, 2);
+            assert_eq!(state.stack.read_u64(0), 0xFFFFFFFFFFFFFFFF); // -1
+        });
+    }
+
+    #[test]
+    fn test_i32_extend16_s() {
+        with_test_context(|state| {
+            let interpreter = Interpreter::default();
+            state.stack.write_u32(0, 0x0000FFFF);
+            state.sp = 1;
+            interpreter.i32_extend16_s(state).unwrap();
+            assert_eq!(state.sp, 1);
+            assert_eq!(state.stack.read_u32(0), 0xFFFFFFFF); // -1
+
+            state.stack.write_u32(0, 0x00007FFF);
+            interpreter.i32_extend16_s(state).unwrap();
+            assert_eq!(state.stack.read_u32(0), 0x00007FFF); // 32767
+        });
+    }
+
+    #[test]
+    fn test_i64_extend16_s() {
+        with_test_context(|state| {
+            let interpreter = Interpreter::default();
+            state.stack.write_u64(0, 0x000000000000FFFF);
+            state.sp = 2;
+            interpreter.i64_extend16_s(state).unwrap();
+            assert_eq!(state.sp, 2);
+            assert_eq!(state.stack.read_u64(0), 0xFFFFFFFFFFFFFFFF); // -1
+        });
+    }
+
+    #[test]
+    fn test_i64_extend32_s() {
+        with_test_context(|state| {
+            let interpreter = Interpreter::default();
+            state.stack.write_u64(0, 0x00000000FFFFFFFF);
+            state.sp = 2;
+            interpreter.i64_extend32_s(state).unwrap();
+            assert_eq!(state.sp, 2);
+            assert_eq!(state.stack.read_u64(0), 0xFFFFFFFFFFFFFFFF); // -1
+        });
+    }
+
     #[test]
     fn test_i32_trunc_f32_s() {
         with_test_context(|state| {

src/ir_reader.rs

@@ -419,6 +419,11 @@ impl<'code> IrReader<'code> {
 
             // Numeric instructions - conversions
             I32_WRAP_I64 => instruction!(i32_wrap_i64),
+            I32_EXTEND8_S => instruction!(i32_extend8_s),
+            I32_EXTEND16_S => instruction!(i32_extend16_s),
+            I64_EXTEND8_S => instruction!(i64_extend8_s),
+            I64_EXTEND16_S => instruction!(i64_extend16_s),
+            I64_EXTEND32_S => instruction!(i64_extend32_s),
             I32_TRUNC_F32_S => instruction!(i32_trunc_f32_s),
             I32_TRUNC_F32_U => instruction!(i32_trunc_f32_u),
             I32_TRUNC_F64_S => instruction!(i32_trunc_f64_s),

src/opcode.rs

@@ -199,3 +199,8 @@ pub(crate) const I32_REINTERPRET_F32: u8 = 0xBC;
 pub(crate) const I64_REINTERPRET_F64: u8 = 0xBD;
 pub(crate) const F32_REINTERPRET_I32: u8 = 0xBE;
 pub(crate) const F64_REINTERPRET_I64: u8 = 0xBF;
+pub(crate) const I32_EXTEND8_S: u8 = 0xC0;
+pub(crate) const I32_EXTEND16_S: u8 = 0xC1;
+pub(crate) const I64_EXTEND8_S: u8 = 0xC2;
+pub(crate) const I64_EXTEND16_S: u8 = 0xC3;
+pub(crate) const I64_EXTEND32_S: u8 = 0xC4;

src/visitor.rs

@@ -187,6 +187,11 @@ pub trait BaseVisitor {
 
     // Numeric instructions - conversions
     visit_fn!(i32_wrap_i64);
+    visit_fn!(i32_extend8_s);
+    visit_fn!(i32_extend16_s);
+    visit_fn!(i64_extend8_s);
+    visit_fn!(i64_extend16_s);
+    visit_fn!(i64_extend32_s);
     visit_fn!(i32_trunc_f32_s);
     visit_fn!(i32_trunc_f32_u);
     visit_fn!(i32_trunc_f64_s);

tests/util/inspector.rs

@@ -215,6 +215,11 @@ impl<'a, S, E, T: BaseVisitor<State = S, Error = E>> BaseVisitor for Inspector<'
 
     // Numeric instructions - conversions
     visit_fn!(i32_wrap_i64);
+    visit_fn!(i32_extend8_s);
+    visit_fn!(i32_extend16_s);
+    visit_fn!(i64_extend8_s);
+    visit_fn!(i64_extend16_s);
+    visit_fn!(i64_extend32_s);
     visit_fn!(i32_trunc_f32_s);
     visit_fn!(i32_trunc_f32_u);
     visit_fn!(i32_trunc_f64_s);