feat: more bit operations

Signed-off-by: Henry <[email protected]>

Author: explodingcamera

Cargo.lock

@@ -70,6 +70,29 @@ macro_rules! arithmetic_method {
     }};
 }
 
+macro_rules! arithmetic_method_self {
+    ($op:ident, $ty:ty, $stack:ident) => {{
+        let a: $ty = $stack.values.pop()?.into();
+        let result = a.$op();
+        $stack.values.push((result as $ty).into());
+    }};
+}
+
+macro_rules! arithmetic_method_cast {
+    ($op:ident, $ty:ty, $ty2:ty, $stack:ident) => {{
+        let [a, b] = $stack.values.pop_n_const::<2>()?;
+        let a: $ty = a.into();
+        let b: $ty = b.into();
+
+        // Cast to unsigned type before operation
+        let a_unsigned: $ty2 = a as $ty2;
+        let b_unsigned: $ty2 = b as $ty2;
+
+        let result = a_unsigned.$op(b_unsigned);
+        $stack.values.push((result as $ty).into());
+    }};
+}
+
 /// Apply an arithmetic operation to two values on the stack
 macro_rules! checked_arithmetic_method {
     ($op:ident, $ty:ty, $stack:ident, $trap:expr) => {{
@@ -105,6 +128,8 @@ macro_rules! checked_arithmetic_method_cast {
 }
 
 pub(super) use arithmetic_method;
+pub(super) use arithmetic_method_cast;
+pub(super) use arithmetic_method_self;
 pub(super) use arithmetic_op;
 pub(super) use checked_arithmetic_method;
 pub(super) use checked_arithmetic_method_cast;

crates/tinywasm/src/runtime/executor/macros.rs

@@ -326,8 +326,23 @@ fn exec_one(
         I64Or => arithmetic_method!(bitor, i64, stack),
         I32Xor => arithmetic_method!(bitxor, i32, stack),
         I64Xor => arithmetic_method!(bitxor, i64, stack),
-        I32Shl => arithmetic_method!(shl_i32, i32, stack),
-        I64Shl => arithmetic_method!(shl_i64, i64, stack),
+        I32Shl => arithmetic_method!(wrapping_shl_self, i32, stack),
+        I64Shl => arithmetic_method!(wrapping_shl_self, i64, stack),
+        I32ShrS => arithmetic_method!(wrapping_shr_self, i32, stack),
+        I64ShrS => arithmetic_method!(wrapping_shr_self, i64, stack),
+        I32ShrU => arithmetic_method_cast!(wrapping_shr_self, i32, u32, stack),
+        I64ShrU => arithmetic_method_cast!(wrapping_shr_self, i64, u64, stack),
+        I32Rotl => arithmetic_method!(wrapping_rotl_self, i32, stack),
+        I64Rotl => arithmetic_method!(wrapping_rotl_self, i64, stack),
+        I32Rotr => arithmetic_method!(wrapping_rotr_self, i32, stack),
+        I64Rotr => arithmetic_method!(wrapping_rotr_self, i64, stack),
+
+        I32Clz => arithmetic_method_self!(leading_zeros, i32, stack),
+        I64Clz => arithmetic_method_self!(leading_zeros, i64, stack),
+        I32Ctz => arithmetic_method_self!(trailing_zeros, i32, stack),
+        I64Ctz => arithmetic_method_self!(trailing_zeros, i64, stack),
+        I32Popcnt => arithmetic_method_self!(count_ones, i32, stack),
+        I64Popcnt => arithmetic_method_self!(count_ones, i64, stack),
 
         F32ConvertI32S => conv_1!(i32, f32, stack),
         F32ConvertI64S => conv_1!(i64, f32, stack),

crates/tinywasm/src/runtime/executor/mod.rs

@@ -5,28 +5,41 @@ where
     fn checked_wrapping_rem(self, rhs: Self) -> Option<Self>;
 }
 
-pub(crate) trait ShlI32 {
-    fn shl_i32(self, rhs: i32) -> Self;
+pub(crate) trait WrappingSelfOps {
+    fn wrapping_shl_self(self, rhs: Self) -> Self;
+    fn wrapping_shr_self(self, rhs: Self) -> Self;
+    fn wrapping_rotl_self(self, rhs: Self) -> Self;
+    fn wrapping_rotr_self(self, rhs: Self) -> Self;
 }
 
-impl ShlI32 for i32 {
-    #[inline]
-    fn shl_i32(self, rhs: i32) -> Self {
-        self.wrapping_shl(rhs as u32)
-    }
-}
+macro_rules! impl_wrapping_self_sh {
+    ($($t:ty)*) => ($(
+        impl WrappingSelfOps for $t {
+            #[inline]
+            fn wrapping_shl_self(self, rhs: Self) -> Self {
+                self.wrapping_shl(rhs as u32)
+            }
 
-pub(crate) trait ShlI64 {
-    fn shl_i64(self, rhs: i64) -> Self;
-}
+            #[inline]
+            fn wrapping_shr_self(self, rhs: Self) -> Self {
+                self.wrapping_shr(rhs as u32)
+            }
 
-impl ShlI64 for i64 {
-    #[inline]
-    fn shl_i64(self, rhs: i64) -> Self {
-        self.wrapping_shl(rhs as u32)
-    }
+            #[inline]
+            fn wrapping_rotl_self(self, rhs: Self) -> Self {
+                self.rotate_left(rhs as u32)
+            }
+
+            #[inline]
+            fn wrapping_rotr_self(self, rhs: Self) -> Self {
+                self.rotate_right(rhs as u32)
+            }
+        }
+    )*)
 }
 
+impl_wrapping_self_sh! { i32 i64 u32 u64 }
+
 macro_rules! impl_checked_wrapping_rem {
     ($($t:ty)*) => ($(
         impl CheckedWrappingRem for $t {
@@ -42,4 +55,4 @@ macro_rules! impl_checked_wrapping_rem {
     )*)
 }
 
-impl_checked_wrapping_rem! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
+impl_checked_wrapping_rem! { i32 i64 u32 u64 }