chore: simplify simd instruction implementations

also updated wasmparser :) Signed-off-by: Henry <mail@henrygressmann.de>
author: Henry <mail@henrygressmann.de> 2026-07-08 16:13:22 +0200
committer: Henry <mail@henrygressmann.de> 2026-07-08 16:13:22 +0200
commit: 6e28708ca6b78419117d27bbae916ac44b90d306 (patch)
tree: 08e41c28caf57cb4e8c6e0f09daad443b2c9444b
parent: 71e8948fbde0a6fd61195501fd4a89609c402bbb (diff)
20 files changed, 325 insertions, 525 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 6a68452..3cb725d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -128,9 +128,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.65"
+version = "1.2.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e228eec9be7c17ccb640b59b36a5cd805ea2a564a4c5e162c2f659fea30d3b96"
+checksum = "f5d6cac793997bd970000024b2934968efe83b382de4fdcf4fcb46b6ee4ad996"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -193,9 +193,9 @@ dependencies = [
 
 [[package]]
 name = "clap_complete"
-version = "4.6.5"
+version = "4.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7a9bfdb35811f9e59832f0f05975114d2251b415fb534108e6f34060fd772"
+checksum = "db8b397918185f0161ff3d6fcaa9e4bfc09b8367caf6e1d4a2848e5477ed027b"
 dependencies = [
  "clap",
 ]
@@ -269,9 +269,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -279,18 +279,18 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.18"
+version = "0.9.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
 
 [[package]]
 name = "crunchy"
@@ -424,9 +424,9 @@ checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "humantime"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+checksum = "15cdd26707701c53297e2fa6afb323d55fbc1d0810c3aec078ae3ef0424c3c15"
 
 [[package]]
 name = "include_dir"
@@ -527,9 +527,9 @@ checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
 
 [[package]]
 name = "memchr"
-version = "2.8.2"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "normalize-line-endings"
@@ -961,9 +961,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.252.0"
+version = "0.253.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8185ae345fa5687c054626ff9a50e7089797a343d9904d1dc9820eb4c4d3196f"
+checksum = "59972d6cd272259de647b7c1f1912e45e289c75ffd4be04e10695507cd7e1b59"
 dependencies = [
  "leb128fmt",
  "wasmparser",
@@ -981,9 +981,9 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.252.0"
+version = "0.253.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3eb099dcadcde5be9eef55e3a337128efd4e44b4c93122487e4d2e4e1c6627c"
+checksum = "19db11f87d2486580e1e8b6f494c54df7e0566b87d0b599db843c24019667339"
 dependencies = [
  "bitflags",
  "indexmap",
@@ -992,9 +992,9 @@ dependencies = [
 
 [[package]]
 name = "wast"
-version = "252.0.0"
+version = "253.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "942a3449d6a593fccc111a6241c8df52bda168af30e40bf9580d4394d7374c65"
+checksum = "d3264542f8965c5d84fb1085d924bfba9a6314bb228eff13a2de14d7627664d0"
 dependencies = [
  "bumpalo",
  "leb128fmt",
@@ -1005,9 +1005,9 @@ dependencies = [
 
 [[package]]
 name = "wat"
-version = "1.252.0"
+version = "1.253.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c72a4ba7088f7bac94cf516e49882bdf97068904a563768cf249efc839ec42cb"
+checksum = "4bfc5ce906144200c972ec617470aa35bd847472e170b26dde3e80541c674055"
 dependencies = [
  "wast",
 ]
@@ -1060,18 +1060,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.52"
+version = "0.8.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce1022995ff5ff5d841ad7d994facc23098cd40152f2c1d11cd607c6f530653f"
+checksum = "75726053136156d419e285b9b7eddaaea9e3fea6ce32eed44a89901f0bd98de1"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.52"
+version = "0.8.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ae7f38b72ec2a254e2b87ef277cf2cd4fb97cbebf944faa6f33354da0867930"
+checksum = "4714fd92cf900833d49538023a9b3915155210801d1c1169eba513b2addefd71"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 5653718..149ccd0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,9 +18,9 @@ pretty_env_logger="0.5"
 serde_json={version="1.0"}
 serde={version="1.0", features=["derive"]}
 wasm-testsuite={version="0.7"}
-wasmparser={version="0.252", default-features=false}
-wast="252"
-wat="1.252"
+wasmparser={version="0.253", default-features=false}
+wast="253"
+wat="1.253"
 
 [workspace.package]
 version="0.9.1"
diff --git a/crates/tinywasm/src/interpreter/simd/instructions.rs b/crates/tinywasm/src/interpreter/simd/instructions.rs
index 957d533..00c387e 100644
--- a/crates/tinywasm/src/interpreter/simd/instructions.rs
+++ b/crates/tinywasm/src/interpreter/simd/instructions.rs
@@ -1,6 +1,7 @@
 use super::super::num_helpers::TinywasmFloatExt;
 use super::Value128;
 use super::utils::*;
+use core::array;
 
 #[cfg(not(feature = "std"))]
 use super::super::no_std_floats::NoStdFloatExt;
@@ -151,11 +152,7 @@ impl Value128 {
             x86 => {
                 let a = self.0;
                 let idx = s.0;
-                let mut mask = [0u8; 16];
-                for i in 0..16 {
-                    let j = idx[i];
-                    mask[i] = if j < 16 { j & 0x0f } else { 0x80 };
-                }
+                let mask = idx.map(|j| if j < 16 { j & 0x0f } else { 0x80 });
 
                 // SAFETY: `a`, `mask`, and `out` are valid 16-byte buffers, and `_mm_loadu/_mm_storeu` support unaligned accesses.
                 #[allow(unsafe_code)]
@@ -173,6 +170,7 @@ impl Value128 {
                 let a = self.0;
                 let idx = s.0;
                 let mut out = [0u8; 16];
+                // Keep this as a manual loop: array::from_fn generates worse x86 asm here.
                 for i in 0..16 {
                     let j = idx[i];
                     let lane = a[(j & 0x0f) as usize];
@@ -195,13 +193,15 @@ impl Value128 {
     pub fn i8x16_shuffle(a: Self, b: Self, idx: Self) -> Self {
         simd_impl! {
             x86 => {
-                let mut mask_a = [0u8; 16];
-                let mut mask_b = [0u8; 16];
-                for i in 0..16 {
-                    let j = idx.0[i] & 31;
-                    mask_a[i] = if j < 16 { j } else { 0x80 };
-                    mask_b[i] = if j < 16 { 0x80 } else { j & 0x0f };
-                }
+                let idx = idx.0;
+                let mask_a = idx.map(|j| {
+                    let j = j & 31;
+                    if j < 16 { j } else { 0x80 }
+                });
+                let mask_b = idx.map(|j| {
+                    let j = j & 31;
+                    if j < 16 { 0x80 } else { j & 0x0f }
+                });
 
                 // SAFETY: all inputs are valid 16-byte buffers, and `_mm_loadu/_mm_storeu` support unaligned accesses.
                 #[allow(unsafe_code)]
@@ -224,6 +224,7 @@ impl Value128 {
                 let b_bytes = b.0;
                 let idx = idx.0;
                 let mut out = [0u8; 16];
+                // Keep this as a manual loop: array::from_fn generates worse x86 asm here.
                 for i in 0..16 {
                     let j = idx[i] & 31;
                     out[i] = if j < 16 { a_bytes[j as usize] } else { b_bytes[(j & 0x0f) as usize] };
@@ -240,32 +241,32 @@ impl Value128 {
 
     #[doc(alias = "i8x16.replace_lane")]
     pub fn i8x16_replace_lane(self, lane: u8, value: i8) -> Self {
-        self.replace_lane_bytes::<1>(lane, [value as u8], 16)
+        self.replace_lane_bytes::<1, 16>(lane, [value as u8])
     }
 
     #[doc(alias = "i16x8.replace_lane")]
     pub fn i16x8_replace_lane(self, lane: u8, value: i16) -> Self {
-        self.replace_lane_bytes::<2>(lane, value.to_le_bytes(), 8)
+        self.replace_lane_bytes::<2, 8>(lane, value.to_le_bytes())
     }
 
     #[doc(alias = "i32x4.replace_lane")]
     pub fn i32x4_replace_lane(self, lane: u8, value: i32) -> Self {
-        self.replace_lane_bytes::<4>(lane, value.to_le_bytes(), 4)
+        self.replace_lane_bytes::<4, 4>(lane, value.to_le_bytes())
     }
 
     #[doc(alias = "i64x2.replace_lane")]
     pub fn i64x2_replace_lane(self, lane: u8, value: i64) -> Self {
-        self.replace_lane_bytes::<8>(lane, value.to_le_bytes(), 2)
+        self.replace_lane_bytes::<8, 2>(lane, value.to_le_bytes())
     }
 
     #[doc(alias = "f32x4.replace_lane")]
     pub fn f32x4_replace_lane(self, lane: u8, value: f32) -> Self {
-        self.replace_lane_bytes::<4>(lane, value.to_bits().to_le_bytes(), 4)
+        self.replace_lane_bytes::<4, 4>(lane, value.to_bits().to_le_bytes())
     }
 
     #[doc(alias = "f64x2.replace_lane")]
     pub fn f64x2_replace_lane(self, lane: u8, value: f64) -> Self {
-        self.replace_lane_bytes::<8>(lane, value.to_bits().to_le_bytes(), 2)
+        self.replace_lane_bytes::<8, 2>(lane, value.to_bits().to_le_bytes())
     }
 
     #[doc(alias = "i8x16.all_true")]
@@ -275,20 +276,17 @@ impl Value128 {
 
     #[doc(alias = "i16x8.all_true")]
     pub fn i16x8_all_true(self) -> bool {
-        self.0.chunks_exact(2).map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]])).all(|x| x != 0)
+        self.as_i16x8().iter().all(|&x| x != 0)
     }
 
     #[doc(alias = "i32x4.all_true")]
     pub fn i32x4_all_true(self) -> bool {
-        self.0.chunks_exact(4).map(|chunk| u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]])).all(|x| x != 0)
+        self.as_i32x4().iter().all(|&x| x != 0)
     }
 
     #[doc(alias = "i64x2.all_true")]
     pub fn i64x2_all_true(self) -> bool {
-        self.0
-            .chunks_exact(8)
-            .map(|c| u64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]]))
-            .all(|x| x != 0)
+        self.as_i64x2().iter().all(|&x| x != 0)
     }
 
     #[doc(alias = "i8x16.bitmask")]
@@ -307,7 +305,7 @@ impl Value128 {
     pub fn i16x8_bitmask(self) -> u32 {
         let bytes = self.0;
         let mut mask = 0u32;
-        for (i, lane) in bytes.chunks_exact(2).enumerate() {
+        for (i, lane) in bytes.as_chunks::<2>().0.iter().enumerate() {
             if (lane[1] & 0x80) != 0 {
                 mask |= 1u32 << i;
             }
@@ -319,7 +317,7 @@ impl Value128 {
     pub fn i32x4_bitmask(self) -> u32 {
         let bytes = self.0;
         let mut mask = 0u32;
-        for (i, lane) in bytes.chunks_exact(4).enumerate() {
+        for (i, lane) in bytes.as_chunks::<4>().0.iter().enumerate() {
             if (lane[3] & 0x80) != 0 {
                 mask |= 1u32 << i;
             }
@@ -335,177 +333,172 @@ impl Value128 {
 
     #[doc(alias = "i8x16.popcnt")]
     pub fn i8x16_popcnt(self) -> Self {
-        let lanes = self.0;
-        let mut out = [0u8; 16];
-        for (dst, lane) in out.iter_mut().zip(lanes) {
-            *dst = lane.count_ones() as u8;
-        }
-        Self(out)
+        Self(self.0.map(|lane| lane.count_ones() as u8))
     }
 
     #[doc(alias = "i8x16.shl")]
     pub fn i8x16_shl(self, shift: u32) -> Self {
-        simd_shift_left!(self, shift, i8, 16, as_i8x16, from_i8x16, 7)
+        simd_shift!(self, shift, as_i8x16, from_i8x16, 7, shl)
     }
 
     #[doc(alias = "i16x8.shl")]
     pub fn i16x8_shl(self, shift: u32) -> Self {
-        simd_shift_left!(self, shift, i16, 8, as_i16x8, from_i16x8, 15)
+        simd_shift!(self, shift, as_i16x8, from_i16x8, 15, shl)
     }
 
     #[doc(alias = "i32x4.shl")]
     pub fn i32x4_shl(self, shift: u32) -> Self {
-        simd_shift_left!(self, shift, i32, 4, as_i32x4, from_i32x4, 31)
+        simd_shift!(self, shift, as_i32x4, from_i32x4, 31, shl)
     }
 
     #[doc(alias = "i64x2.shl")]
     pub fn i64x2_shl(self, shift: u32) -> Self {
-        simd_shift_left!(self, shift, i64, 2, as_i64x2, from_i64x2, 63)
+        simd_shift!(self, shift, as_i64x2, from_i64x2, 63, shl)
     }
 
     #[doc(alias = "i8x16.shr_s")]
     pub fn i8x16_shr_s(self, shift: u32) -> Self {
-        simd_shift_right!(self, shift, i8, 16, as_i8x16, from_i8x16, 7)
+        simd_shift!(self, shift, as_i8x16, from_i8x16, 7, shr)
     }
 
     #[doc(alias = "i16x8.shr_s")]
     pub fn i16x8_shr_s(self, shift: u32) -> Self {
-        simd_shift_right!(self, shift, i16, 8, as_i16x8, from_i16x8, 15)
+        simd_shift!(self, shift, as_i16x8, from_i16x8, 15, shr)
     }
 
     #[doc(alias = "i32x4.shr_s")]
     pub fn i32x4_shr_s(self, shift: u32) -> Self {
-        simd_shift_right!(self, shift, i32, 4, as_i32x4, from_i32x4, 31)
+        simd_shift!(self, shift, as_i32x4, from_i32x4, 31, shr)
     }
 
     #[doc(alias = "i64x2.shr_s")]
     pub fn i64x2_shr_s(self, shift: u32) -> Self {
-        simd_shift_right!(self, shift, i64, 2, as_i64x2, from_i64x2, 63)
+        simd_shift!(self, shift, as_i64x2, from_i64x2, 63, shr)
     }
 
     #[doc(alias = "i8x16.shr_u")]
     pub fn i8x16_shr_u(self, shift: u32) -> Self {
-        simd_shift_right!(self, shift, u8, 16, as_u8x16, from_u8x16, 7)
+        simd_shift!(self, shift, as_u8x16, from_u8x16, 7, shr)
     }
 
     #[doc(alias = "i16x8.shr_u")]
     pub fn i16x8_shr_u(self, shift: u32) -> Self {
-        simd_shift_right!(self, shift, u16, 8, as_u16x8, from_u16x8, 15)
+        simd_shift!(self, shift, as_u16x8, from_u16x8, 15, shr)
     }
 
     #[doc(alias = "i32x4.shr_u")]
     pub fn i32x4_shr_u(self, shift: u32) -> Self {
-        simd_shift_right!(self, shift, u32, 4, as_u32x4, from_u32x4, 31)
+        simd_shift!(self, shift, as_u32x4, from_u32x4, 31, shr)
     }
 
     #[doc(alias = "i64x2.shr_u")]
     pub fn i64x2_shr_u(self, shift: u32) -> Self {
-        simd_shift_right!(self, shift, u64, 2, as_u64x2, from_u64x2, 63)
+        simd_shift!(self, shift, as_u64x2, from_u64x2, 63, shr)
     }
 
     #[doc(alias = "i8x16.add")]
     pub fn i8x16_add(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i8x16_add, i8, 16, as_i8x16, from_i8x16, wrapping_add)
+        simd_binop!(self, rhs, i8x16_add, as_i8x16, from_i8x16, wrapping_add)
     }
 
     #[doc(alias = "i16x8.add")]
     pub fn i16x8_add(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i16x8_add, i16, 8, as_i16x8, from_i16x8, wrapping_add)
+        simd_binop!(self, rhs, i16x8_add, as_i16x8, from_i16x8, wrapping_add)
     }
 
     #[doc(alias = "i32x4.add")]
     pub fn i32x4_add(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i32x4_add, i32, 4, as_i32x4, from_i32x4, wrapping_add)
+        simd_binop!(self, rhs, i32x4_add, as_i32x4, from_i32x4, wrapping_add)
     }
 
     #[doc(alias = "i64x2.add")]
     pub fn i64x2_add(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i64x2_add, i64, 2, as_i64x2, from_i64x2, wrapping_add)
+        simd_binop!(self, rhs, i64x2_add, as_i64x2, from_i64x2, wrapping_add)
     }
 
     #[doc(alias = "i8x16.sub")]
     pub fn i8x16_sub(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i8x16_sub, i8, 16, as_i8x16, from_i8x16, wrapping_sub)
+        simd_binop!(self, rhs, i8x16_sub, as_i8x16, from_i8x16, wrapping_sub)
     }
 
     #[doc(alias = "i16x8.sub")]
     pub fn i16x8_sub(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i16x8_sub, i16, 8, as_i16x8, from_i16x8, wrapping_sub)
+        simd_binop!(self, rhs, i16x8_sub, as_i16x8, from_i16x8, wrapping_sub)
     }
 
     #[doc(alias = "i32x4.sub")]
     pub fn i32x4_sub(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i32x4_sub, i32, 4, as_i32x4, from_i32x4, wrapping_sub)
+        simd_binop!(self, rhs, i32x4_sub, as_i32x4, from_i32x4, wrapping_sub)
     }
 
     #[doc(alias = "i64x2.sub")]
     pub fn i64x2_sub(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i64x2_sub, i64, 2, as_i64x2, from_i64x2, wrapping_sub)
+        simd_binop!(self, rhs, i64x2_sub, as_i64x2, from_i64x2, wrapping_sub)
     }
 
     #[doc(alias = "i16x8.mul")]
     pub fn i16x8_mul(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i16x8_mul, i16, 8, as_i16x8, from_i16x8, wrapping_mul)
+        simd_binop!(self, rhs, i16x8_mul, as_i16x8, from_i16x8, wrapping_mul)
     }
 
     #[doc(alias = "i32x4.mul")]
     pub fn i32x4_mul(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i32x4_mul, i32, 4, as_i32x4, from_i32x4, wrapping_mul)
+        simd_binop!(self, rhs, i32x4_mul, as_i32x4, from_i32x4, wrapping_mul)
     }
 
     #[doc(alias = "i64x2.mul")]
     pub fn i64x2_mul(self, rhs: Self) -> Self {
-        simd_wrapping_binop!(self, rhs, i64x2_mul, i64, 2, as_i64x2, from_i64x2, wrapping_mul)
+        simd_binop!(self, rhs, i64x2_mul, as_i64x2, from_i64x2, wrapping_mul)
     }
 
     #[doc(alias = "i8x16.add_sat_s")]
     pub fn i8x16_add_sat_s(self, rhs: Self) -> Self {
-        simd_sat_binop!(self, rhs, i8x16_add_sat, i8, 16, as_i8x16, from_i8x16, saturating_add)
+        simd_binop!(self, rhs, i8x16_add_sat, as_i8x16, from_i8x16, saturating_add)
     }
 
     #[doc(alias = "i16x8.add_sat_s")]
     pub fn i16x8_add_sat_s(self, rhs: Self) -> Self {
-        simd_sat_binop!(self, rhs, i16x8_add_sat, i16, 8, as_i16x8, from_i16x8, saturating_add)
+        simd_binop!(self, rhs, i16x8_add_sat, as_i16x8, from_i16x8, saturating_add)
     }
 
     #[doc(alias = "i8x16.add_sat_u")]
     pub fn i8x16_add_sat_u(self, rhs: Self) -> Self {
-        simd_sat_binop!(self, rhs, u8x16_add_sat, u8, 16, as_u8x16, from_u8x16, saturating_add)
+        simd_binop!(self, rhs, u8x16_add_sat, as_u8x16, from_u8x16, saturating_add)
     }
 
     #[doc(alias = "i16x8.add_sat_u")]
     pub fn i16x8_add_sat_u(self, rhs: Self) -> Self {
-        simd_sat_binop!(self, rhs, u16x8_add_sat, u16, 8, as_u16x8, from_u16x8, saturating_add)
+        simd_binop!(self, rhs, u16x8_add_sat, as_u16x8, from_u16x8, saturating_add)
     }
 
     #[doc(alias = "i8x16.sub_sat_s")]
     pub fn i8x16_sub_sat_s(self, rhs: Self) -> Self {
-        simd_sat_binop!(self, rhs, i8x16_sub_sat, i8, 16, as_i8x16, from_i8x16, saturating_sub)
+        simd_binop!(self, rhs, i8x16_sub_sat, as_i8x16, from_i8x16, saturating_sub)
     }
 
     #[doc(alias = "i16x8.sub_sat_s")]
     pub fn i16x8_sub_sat_s(self, rhs: Self) -> Self {
-        simd_sat_binop!(self, rhs, i16x8_sub_sat, i16, 8, as_i16x8, from_i16x8, saturating_sub)
+        simd_binop!(self, rhs, i16x8_sub_sat, as_i16x8, from_i16x8, saturating_sub)
     }
 
     #[doc(alias = "i8x16.sub_sat_u")]
     pub fn i8x16_sub_sat_u(self, rhs: Self) -> Self {
-        simd_sat_binop!(self, rhs, u8x16_sub_sat, u8, 16, as_u8x16, from_u8x16, saturating_sub)
+        simd_binop!(self, rhs, u8x16_sub_sat, as_u8x16, from_u8x16, saturating_sub)
     }
 
     #[doc(alias = "i16x8.sub_sat_u")]
     pub fn i16x8_sub_sat_u(self, rhs: Self) -> Self {
-        simd_sat_binop!(self, rhs, u16x8_sub_sat, u16, 8, as_u16x8, from_u16x8, saturating_sub)
+        simd_binop!(self, rhs, u16x8_sub_sat, as_u16x8, from_u16x8, saturating_sub)
     }
 
     #[doc(alias = "i8x16.avgr_u")]
     pub fn i8x16_avgr_u(self, rhs: Self) -> Self {
-        simd_avgr_u!(self, rhs, u8x16_avgr, u8, u16, 16, as_u8x16, from_u8x16)
+        simd_avgr_u!(self, rhs, u8x16_avgr, u8, u16, as_u8x16, from_u8x16)
     }
 
     #[doc(alias = "i16x8.avgr_u")]
     pub fn i16x8_avgr_u(self, rhs: Self) -> Self {
-        simd_avgr_u!(self, rhs, u16x8_avgr, u16, u32, 8, as_u16x8, from_u16x8)
+        simd_avgr_u!(self, rhs, u16x8_avgr, u16, u32, as_u16x8, from_u16x8)
     }
 
     #[doc(alias = "i8x16.narrow_i16x8_s")]
@@ -563,161 +556,145 @@ impl Value128 {
     #[doc(alias = "i16x8.extadd_pairwise_i8x16_s")]
     pub fn i16x8_extadd_pairwise_i8x16_s(self) -> Self {
         let lanes = self.as_i8x16();
-        let mut out = [0i16; 8];
-        for (dst, pair) in out.iter_mut().zip(lanes.as_chunks::<2>().0) {
-            *dst = pair[0] as i16 + pair[1] as i16;
-        }
-        Self::from_i16x8(out)
+        Self::from_i16x8(array::from_fn(|i| lanes[i * 2] as i16 + lanes[i * 2 + 1] as i16))
     }
 
     #[doc(alias = "i16x8.extadd_pairwise_i8x16_u")]
     pub fn i16x8_extadd_pairwise_i8x16_u(self) -> Self {
         let lanes = self.as_u8x16();
-        let mut out = [0u16; 8];
-        for (dst, pair) in out.iter_mut().zip(lanes.as_chunks::<2>().0) {
-            *dst = pair[0] as u16 + pair[1] as u16;
-        }
-        Self::from_u16x8(out)
+        Self::from_u16x8(array::from_fn(|i| lanes[i * 2] as u16 + lanes[i * 2 + 1] as u16))
     }
 
     #[doc(alias = "i32x4.extadd_pairwise_i16x8_s")]
     pub fn i32x4_extadd_pairwise_i16x8_s(self) -> Self {
         let lanes = self.as_i16x8();
-        let mut out = [0i32; 4];
-        for (dst, pair) in out.iter_mut().zip(lanes.as_chunks::<2>().0) {
-            *dst = pair[0] as i32 + pair[1] as i32;
-        }
-        Self::from_i32x4(out)
+        Self::from_i32x4(array::from_fn(|i| lanes[i * 2] as i32 + lanes[i * 2 + 1] as i32))
     }
 
     #[doc(alias = "i32x4.extadd_pairwise_i16x8_u")]
     pub fn i32x4_extadd_pairwise_i16x8_u(self) -> Self {
         let lanes = self.as_u16x8();
-        let mut out = [0u32; 4];
-        for (dst, pair) in out.iter_mut().zip(lanes.as_chunks::<2>().0) {
-            *dst = pair[0] as u32 + pair[1] as u32;
-        }
-        Self::from_u32x4(out)
+        Self::from_u32x4(array::from_fn(|i| lanes[i * 2] as u32 + lanes[i * 2 + 1] as u32))
     }
 
     #[doc(alias = "i16x8.extend_low_i8x16_s")]
     pub fn i16x8_extend_low_i8x16_s(self) -> Self {
-        simd_extend_cast!(self, as_i8x16, from_i16x8, i16, 8, 0)
+        simd_extend_cast!(self, as_i8x16, from_i16x8, i16, 0)
     }
 
     #[doc(alias = "i16x8.extend_low_i8x16_u")]
     pub fn i16x8_extend_low_i8x16_u(self) -> Self {
-        simd_extend_cast!(self, as_u8x16, from_u16x8, u16, 8, 0)
+        simd_extend_cast!(self, as_u8x16, from_u16x8, u16, 0)
     }
 
     #[doc(alias = "i16x8.extend_high_i8x16_s")]
     pub fn i16x8_extend_high_i8x16_s(self) -> Self {
-        simd_extend_cast!(self, as_i8x16, from_i16x8, i16, 8, 8)
+        simd_extend_cast!(self, as_i8x16, from_i16x8, i16, 8)
     }
 
     #[doc(alias = "i16x8.extend_high_i8x16_u")]
     pub fn i16x8_extend_high_i8x16_u(self) -> Self {
-        simd_extend_cast!(self, as_u8x16, from_u16x8, u16, 8, 8)
+        simd_extend_cast!(self, as_u8x16, from_u16x8, u16, 8)
     }
 
     #[doc(alias = "i32x4.extend_low_i16x8_s")]
     pub fn i32x4_extend_low_i16x8_s(self) -> Self {
-        simd_extend_cast!(self, as_i16x8, from_i32x4, i32, 4, 0)
+        simd_extend_cast!(self, as_i16x8, from_i32x4, i32, 0)
     }
 
     #[doc(alias = "i32x4.extend_low_i16x8_u")]
     pub fn i32x4_extend_low_i16x8_u(self) -> Self {
-        simd_extend_cast!(self, as_u16x8, from_u32x4, u32, 4, 0)
+        simd_extend_cast!(self, as_u16x8, from_u32x4, u32, 0)
     }
 
     #[doc(alias = "i32x4.extend_high_i16x8_s")]
     pub fn i32x4_extend_high_i16x8_s(self) -> Self {
-        simd_extend_cast!(self, as_i16x8, from_i32x4, i32, 4, 4)
+        simd_extend_cast!(self, as_i16x8, from_i32x4, i32, 4)
     }
 
     #[doc(alias = "i32x4.extend_high_i16x8_u")]
     pub fn i32x4_extend_high_i16x8_u(self) -> Self {
-        simd_extend_cast!(self, as_u16x8, from_u32x4, u32, 4, 4)
+        simd_extend_cast!(self, as_u16x8, from_u32x4, u32, 4)
     }
 
     #[doc(alias = "i64x2.extend_low_i32x4_s")]
     pub fn i64x2_extend_low_i32x4_s(self) -> Self {
-        simd_extend_cast!(self, as_i32x4, from_i64x2, i64, 2, 0)
+        simd_extend_cast!(self, as_i32x4, from_i64x2, i64, 0)
     }
 
     #[doc(alias = "i64x2.extend_low_i32x4_u")]
     pub fn i64x2_extend_low_i32x4_u(self) -> Self {
-        simd_extend_cast!(self, as_u32x4, from_u64x2, u64, 2, 0)
+        simd_extend_cast!(self, as_u32x4, from_u64x2, u64, 0)
     }
 
     #[doc(alias = "i64x2.extend_high_i32x4_s")]
     pub fn i64x2_extend_high_i32x4_s(self) -> Self {
-        simd_extend_cast!(self, as_i32x4, from_i64x2, i64, 2, 2)
+        simd_extend_cast!(self, as_i32x4, from_i64x2, i64, 2)
     }
 
     #[doc(alias = "i64x2.extend_high_i32x4_u")]
     pub fn i64x2_extend_high_i32x4_u(self) -> Self {
-        simd_extend_cast!(self, as_u32x4, from_u64x2, u64, 2, 2)
+        simd_extend_cast!(self, as_u32x4, from_u64x2, u64, 2)
     }
 
     #[doc(alias = "i16x8.extmul_low_i8x16_s")]
     pub fn i16x8_extmul_low_i8x16_s(self, rhs: Self) -> Self {
-        simd_extmul_signed!(self, rhs, as_i8x16, from_i16x8, i16, 8, 0)
+        simd_extmul!(self, rhs, as_i8x16, from_i16x8, i16, 0)
     }
 
     #[doc(alias = "i16x8.extmul_low_i8x16_u")]
     pub fn i16x8_extmul_low_i8x16_u(self, rhs: Self) -> Self {
-        simd_extmul_unsigned!(self, rhs, as_u8x16, from_u16x8, u16, 8, 0)
+        simd_extmul!(self, rhs, as_u8x16, from_u16x8, u16, 0)
     }
 
     #[doc(alias = "i16x8.extmul_high_i8x16_s")]
     pub fn i16x8_extmul_high_i8x16_s(self, rhs: Self) -> Self {
-        simd_extmul_signed!(self, rhs, as_i8x16, from_i16x8, i16, 8, 8)
+        simd_extmul!(self, rhs, as_i8x16, from_i16x8, i16, 8)
     }
 
     #[doc(alias = "i16x8.extmul_high_i8x16_u")]
     pub fn i16x8_extmul_high_i8x16_u(self, rhs: Self) -> Self {
-        simd_extmul_unsigned!(self, rhs, as_u8x16, from_u16x8, u16, 8, 8)
+        simd_extmul!(self, rhs, as_u8x16, from_u16x8, u16, 8)
     }
 
     #[doc(alias = "i32x4.extmul_low_i16x8_s")]
     pub fn i32x4_extmul_low_i16x8_s(self, rhs: Self) -> Self {
-        simd_extmul_signed!(self, rhs, as_i16x8, from_i32x4, i32, 4, 0)
+        simd_extmul!(self, rhs, as_i16x8, from_i32x4, i32, 0)
     }
 
     #[doc(alias = "i32x4.extmul_low_i16x8_u")]
     pub fn i32x4_extmul_low_i16x8_u(self, rhs: Self) -> Self {
-        simd_extmul_unsigned!(self, rhs, as_u16x8, from_u32x4, u32, 4, 0)
+        simd_extmul!(self, rhs, as_u16x8, from_u32x4, u32, 0)
     }
 
     #[doc(alias = "i32x4.extmul_high_i16x8_s")]
     pub fn i32x4_extmul_high_i16x8_s(self, rhs: Self) -> Self {
-        simd_extmul_signed!(self, rhs, as_i16x8, from_i32x4, i32, 4, 4)
+        simd_extmul!(self, rhs, as_i16x8, from_i32x4, i32, 4)
     }
 
     #[doc(alias = "i32x4.extmul_high_i16x8_u")]
     pub fn i32x4_extmul_high_i16x8_u(self, rhs: Self) -> Self {
-        simd_extmul_unsigned!(self, rhs, as_u16x8, from_u32x4, u32, 4, 4)
+        simd_extmul!(self, rhs, as_u16x8, from_u32x4, u32, 4)
     }
 
     #[doc(alias = "i64x2.extmul_low_i32x4_s")]
     pub fn i64x2_extmul_low_i32x4_s(self, rhs: Self) -> Self {
-        simd_extmul_signed!(self, rhs, as_i32x4, from_i64x2, i64, 2, 0)
+        simd_extmul!(self, rhs, as_i32x4, from_i64x2, i64, 0)
     }
 
     #[doc(alias = "i64x2.extmul_low_i32x4_u")]
     pub fn i64x2_extmul_low_i32x4_u(self, rhs: Self) -> Self {
-        simd_extmul_unsigned!(self, rhs, as_u32x4, from_u64x2, u64, 2, 0)
+        simd_extmul!(self, rhs, as_u32x4, from_u64x2, u64, 0)
     }
 
     #[doc(alias = "i64x2.extmul_high_i32x4_s")]
     pub fn i64x2_extmul_high_i32x4_s(self, rhs: Self) -> Self {
-        simd_extmul_signed!(self, rhs, as_i32x4, from_i64x2, i64, 2, 2)
+        simd_extmul!(self, rhs, as_i32x4, from_i64x2, i64, 2)
     }
 
     #[doc(alias = "i64x2.extmul_high_i32x4_u")]
     pub fn i64x2_extmul_high_i32x4_u(self, rhs: Self) -> Self {
-        simd_extmul_unsigned!(self, rhs, as_u32x4, from_u64x2, u64, 2, 2)
+        simd_extmul!(self, rhs, as_u32x4, from_u64x2, u64, 2)
     }
 
     #[doc(alias = "i16x8.q15mulr_sat_s")]
@@ -727,13 +704,7 @@ impl Value128 {
         let mut out = [0i16; 8];
         for ((dst, lhs), rhs) in out.iter_mut().zip(a).zip(b) {
             let r = ((lhs as i32 * rhs as i32) + (1 << 14)) >> 15; // 2^14: Q15 rounding
-            *dst = if r > i16::MAX as i32 {
-                i16::MAX
-            } else if r < i16::MIN as i32 {
-                i16::MIN
-            } else {
-                r as i16
-            };
+            *dst = r.clamp(i16::MIN as i32, i16::MAX as i32) as i16;
         }
         Self::from_i16x8(out)
     }
@@ -742,13 +713,12 @@ impl Value128 {
     pub fn i32x4_dot_i16x8_s(self, rhs: Self) -> Self {
         let a = self.as_i16x8();
         let b = rhs.as_i16x8();
-        let mut out = [0i32; 4];
-        for (dst, (a_pair, b_pair)) in out.iter_mut().zip(a.as_chunks::<2>().0.iter().zip(b.as_chunks::<2>().0)) {
-            *dst = (a_pair[0] as i32)
-                .wrapping_mul(b_pair[0] as i32)
-                .wrapping_add((a_pair[1] as i32).wrapping_mul(b_pair[1] as i32));
-        }
-        Self::from_i32x4(out)
+        Self::from_i32x4(array::from_fn(|i| {
+            let base = i * 2;
+            (a[base] as i32)
+                .wrapping_mul(b[base] as i32)
+                .wrapping_add((a[base + 1] as i32).wrapping_mul(b[base + 1] as i32))
+        }))
     }
 
     #[doc(alias = "i8x16.relaxed_laneselect")]
@@ -780,15 +750,12 @@ impl Value128 {
     pub fn i16x8_relaxed_dot_i8x16_i7x16_s(self, rhs: Self) -> Self {
         let a = self.as_i8x16();
         let b = rhs.as_i8x16();
-        let mut out = [0i16; 8];
-
-        for (dst, (a_pair, b_pair)) in out.iter_mut().zip(a.as_chunks::<2>().0.iter().zip(b.as_chunks::<2>().0)) {
-            let prod0 = (a_pair[0] as i16) * (b_pair[0] as i16);
-            let prod1 = (a_pair[1] as i16) * (b_pair[1] as i16);
-            *dst = prod0.wrapping_add(prod1);
-        }
-
-        Self::from_i16x8(out)
+        Self::from_i16x8(array::from_fn(|i| {
+            let base = i * 2;
+            let prod0 = (a[base] as i16) * (b[base] as i16);
+            let prod1 = (a[base + 1] as i16) * (b[base + 1] as i16);
+            prod0.wrapping_add(prod1)
+        }))
     }
 
     #[doc(alias = "i32x4.relaxed_dot_i8x16_i7x16_add_s")]
@@ -796,328 +763,324 @@ impl Value128 {
         let a = self.as_i8x16();
         let b = rhs.as_i8x16();
         let c = acc.as_i32x4();
-        let mut out = [0i32; 4];
-
-        for (i, dst) in out.iter_mut().enumerate() {
+        Self::from_i32x4(array::from_fn(|i| {
             let base = i * 4;
-            let mut sum = 0i32;
+            let mut sum = c[i];
             for j in 0..4 {
                 sum = sum.wrapping_add((a[base + j] as i32).wrapping_mul(b[base + j] as i32));
             }
-            *dst = sum.wrapping_add(c[i]);
-        }
-
-        Self::from_i32x4(out)
+            sum
+        }))
     }
 
     #[doc(alias = "i8x16.eq")]
     pub fn i8x16_eq(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i8x16_eq, i8, 16, as_i8x16, from_i8x16, ==)
+        simd_cmp_mask!(self, rhs, i8x16_eq, as_i8x16, from_i8x16, ==)
     }
 
     #[doc(alias = "i16x8.eq")]
     pub fn i16x8_eq(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i16x8_eq, i16, 8, as_i16x8, from_i16x8, ==)
+        simd_cmp_mask!(self, rhs, i16x8_eq, as_i16x8, from_i16x8, ==)
     }
 
     #[doc(alias = "i32x4.eq")]
     pub fn i32x4_eq(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i32x4_eq, i32, 4, as_i32x4, from_i32x4, ==)
+        simd_cmp_mask!(self, rhs, i32x4_eq, as_i32x4, from_i32x4, ==)
     }
 
     #[doc(alias = "i64x2.eq")]
     pub fn i64x2_eq(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i64x2_eq, i64, 2, as_i64x2, from_i64x2, ==)
+        simd_cmp_mask!(self, rhs, i64x2_eq, as_i64x2, from_i64x2, ==)
     }
 
     #[doc(alias = "i8x16.ne")]
     pub fn i8x16_ne(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i8x16_ne, i8, 16, as_i8x16, from_i8x16, !=)
+        simd_cmp_mask!(self, rhs, i8x16_ne, as_i8x16, from_i8x16, !=)
     }
 
     #[doc(alias = "i16x8.ne")]
     pub fn i16x8_ne(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i16x8_ne, i16, 8, as_i16x8, from_i16x8, !=)
+        simd_cmp_mask!(self, rhs, i16x8_ne, as_i16x8, from_i16x8, !=)
     }
 
     #[doc(alias = "i32x4.ne")]
     pub fn i32x4_ne(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i32x4_ne, i32, 4, as_i32x4, from_i32x4, !=)
+        simd_cmp_mask!(self, rhs, i32x4_ne, as_i32x4, from_i32x4, !=)
     }
 
     #[doc(alias = "i64x2.ne")]
     pub fn i64x2_ne(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i64x2_ne, i64, 2, as_i64x2, from_i64x2, !=)
+        simd_cmp_mask!(self, rhs, i64x2_ne, as_i64x2, from_i64x2, !=)
     }
 
     #[doc(alias = "i8x16.lt_s")]
     pub fn i8x16_lt_s(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i8x16_lt, i8, 16, as_i8x16, from_i8x16, <)
+        simd_cmp_mask!(self, rhs, i8x16_lt, as_i8x16, from_i8x16, <)
     }
 
     #[doc(alias = "i16x8.lt_s")]
     pub fn i16x8_lt_s(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i16x8_lt, i16, 8, as_i16x8, from_i16x8, <)
+        simd_cmp_mask!(self, rhs, i16x8_lt, as_i16x8, from_i16x8, <)
     }
 
     #[doc(alias = "i32x4.lt_s")]
     pub fn i32x4_lt_s(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i32x4_lt, i32, 4, as_i32x4, from_i32x4, <)
+        simd_cmp_mask!(self, rhs, i32x4_lt, as_i32x4, from_i32x4, <)
     }
 
     #[doc(alias = "i64x2.lt_s")]
     pub fn i64x2_lt_s(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i64x2_lt, i64, 2, as_i64x2, from_i64x2, <)
+        simd_cmp_mask!(self, rhs, i64x2_lt, as_i64x2, from_i64x2, <)
     }
 
     #[doc(alias = "i8x16.lt_u")]
     pub fn i8x16_lt_u(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, u8x16_lt, i8, 16, as_u8x16, from_i8x16, <)
+        simd_cmp_mask!(self, rhs, u8x16_lt, as_u8x16, from_i8x16, <)
     }
 
     #[doc(alias = "i16x8.lt_u")]
     pub fn i16x8_lt_u(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, u16x8_lt, i16, 8, as_u16x8, from_i16x8, <)
+        simd_cmp_mask!(self, rhs, u16x8_lt, as_u16x8, from_i16x8, <)
     }
 
     #[doc(alias = "i32x4.lt_u")]
     pub fn i32x4_lt_u(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, u32x4_lt, i32, 4, as_u32x4, from_i32x4, <)
+        simd_cmp_mask!(self, rhs, u32x4_lt, as_u32x4, from_i32x4, <)
     }
 
     #[doc(alias = "i8x16.gt_s")]
     pub fn i8x16_gt_s(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i8x16_lt_s)
+        rhs.i8x16_lt_s(self)
     }
 
     #[doc(alias = "i16x8.gt_s")]
     pub fn i16x8_gt_s(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i16x8_lt_s)
+        rhs.i16x8_lt_s(self)
     }
 
     #[doc(alias = "i32x4.gt_s")]
     pub fn i32x4_gt_s(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i32x4_lt_s)
+        rhs.i32x4_lt_s(self)
     }
 
     #[doc(alias = "i64x2.gt_s")]
     pub fn i64x2_gt_s(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i64x2_lt_s)
+        rhs.i64x2_lt_s(self)
     }
 
     #[doc(alias = "i8x16.gt_u")]
     pub fn i8x16_gt_u(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i8x16_lt_u)
+        rhs.i8x16_lt_u(self)
     }
 
     #[doc(alias = "i16x8.gt_u")]
     pub fn i16x8_gt_u(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i16x8_lt_u)
+        rhs.i16x8_lt_u(self)
     }
 
     #[doc(alias = "i32x4.gt_u")]
     pub fn i32x4_gt_u(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i32x4_lt_u)
+        rhs.i32x4_lt_u(self)
     }
 
     #[doc(alias = "i8x16.le_s")]
     pub fn i8x16_le_s(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i8x16_ge_s)
+        rhs.i8x16_ge_s(self)
     }
 
     #[doc(alias = "i16x8.le_s")]
     pub fn i16x8_le_s(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i16x8_ge_s)
+        rhs.i16x8_ge_s(self)
     }
 
     #[doc(alias = "i32x4.le_s")]
     pub fn i32x4_le_s(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i32x4_ge_s)
+        rhs.i32x4_ge_s(self)
     }
 
     #[doc(alias = "i64x2.le_s")]
     pub fn i64x2_le_s(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i64x2_ge_s)
+        rhs.i64x2_ge_s(self)
     }
 
     #[doc(alias = "i8x16.le_u")]
     pub fn i8x16_le_u(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i8x16_ge_u)
+        rhs.i8x16_ge_u(self)
     }
 
     #[doc(alias = "i16x8.le_u")]
     pub fn i16x8_le_u(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i16x8_ge_u)
+        rhs.i16x8_ge_u(self)
     }
 
     #[doc(alias = "i32x4.le_u")]
     pub fn i32x4_le_u(self, rhs: Self) -> Self {
-        simd_cmp_delegate!(self, rhs, i32x4_ge_u)
+        rhs.i32x4_ge_u(self)
     }
 
     #[doc(alias = "i8x16.ge_s")]
     pub fn i8x16_ge_s(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i8x16_ge, i8, 16, as_i8x16, from_i8x16, >=)
+        simd_cmp_mask!(self, rhs, i8x16_ge, as_i8x16, from_i8x16, >=)
     }
 
     #[doc(alias = "i16x8.ge_s")]
     pub fn i16x8_ge_s(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i16x8_ge, i16, 8, as_i16x8, from_i16x8, >=)
+        simd_cmp_mask!(self, rhs, i16x8_ge, as_i16x8, from_i16x8, >=)
     }
 
     #[doc(alias = "i32x4.ge_s")]
     pub fn i32x4_ge_s(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i32x4_ge, i32, 4, as_i32x4, from_i32x4, >=)
+        simd_cmp_mask!(self, rhs, i32x4_ge, as_i32x4, from_i32x4, >=)
     }
 
     #[doc(alias = "i64x2.ge_s")]
     pub fn i64x2_ge_s(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, i64x2_ge, i64, 2, as_i64x2, from_i64x2, >=)
+        simd_cmp_mask!(self, rhs, i64x2_ge, as_i64x2, from_i64x2, >=)
     }
 
     #[doc(alias = "i8x16.ge_u")]
     pub fn i8x16_ge_u(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, u8x16_ge, i8, 16, as_u8x16, from_i8x16, >=)
+        simd_cmp_mask!(self, rhs, u8x16_ge, as_u8x16, from_i8x16, >=)
     }
 
     #[doc(alias = "i16x8.ge_u")]
     pub fn i16x8_ge_u(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, u16x8_ge, i16, 8, as_u16x8, from_i16x8, >=)
+        simd_cmp_mask!(self, rhs, u16x8_ge, as_u16x8, from_i16x8, >=)
     }
 
     #[doc(alias = "i32x4.ge_u")]
     pub fn i32x4_ge_u(self, rhs: Self) -> Self {
-        simd_cmp_mask!(self, rhs, u32x4_ge, i32, 4, as_u32x4, from_i32x4, >=)
+        simd_cmp_mask!(self, rhs, u32x4_ge, as_u32x4, from_i32x4, >=)
     }
 
     #[doc(alias = "i8x16.abs")]
     pub fn i8x16_abs(self) -> Self {
-        simd_abs_const!(self, i8, 16, as_i8x16, from_i8x16)
+        simd_abs_const!(self, as_i8x16, from_i8x16)
     }
 
     #[doc(alias = "i16x8.abs")]
     pub fn i16x8_abs(self) -> Self {
-        simd_abs_const!(self, i16, 8, as_i16x8, from_i16x8)
+        simd_abs_const!(self, as_i16x8, from_i16x8)
     }
 
     #[doc(alias = "i32x4.abs")]
     pub fn i32x4_abs(self) -> Self {
-        simd_abs_const!(self, i32, 4, as_i32x4, from_i32x4)
+        simd_abs_const!(self, as_i32x4, from_i32x4)
     }
 
     #[doc(alias = "i64x2.abs")]
     pub fn i64x2_abs(self) -> Self {
-        simd_abs_const!(self, i64, 2, as_i64x2, from_i64x2)
+        simd_abs_const!(self, as_i64x2, from_i64x2)
     }
 
     #[doc(alias = "i8x16.neg")]
     pub fn i8x16_neg(self) -> Self {
-        simd_neg!(self, i8x16_neg, i8, 16, as_i8x16, from_i8x16)
+        simd_neg!(self, i8x16_neg, as_i8x16, from_i8x16)
     }
 
     #[doc(alias = "i16x8.neg")]
     pub fn i16x8_neg(self) -> Self {
-        simd_neg!(self, i16x8_neg, i16, 8, as_i16x8, from_i16x8)
+        simd_neg!(self, i16x8_neg, as_i16x8, from_i16x8)
     }
 
     #[doc(alias = "i32x4.neg")]
     pub fn i32x4_neg(self) -> Self {
-        simd_neg!(self, i32x4_neg, i32, 4, as_i32x4, from_i32x4)
+        simd_neg!(self, i32x4_neg, as_i32x4, from_i32x4)
     }
 
     #[doc(alias = "i64x2.neg")]
     pub fn i64x2_neg(self) -> Self {
-        simd_neg!(self, i64x2_neg, i64, 2, as_i64x2, from_i64x2)
+        simd_neg!(self, i64x2_neg, as_i64x2, from_i64x2)
     }
 
     #[doc(alias = "i8x16.min_s")]
     pub fn i8x16_min_s(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, i8x16_min, i8, 16, as_i8x16, from_i8x16, <)
+        simd_minmax!(self, rhs, i8x16_min, as_i8x16, from_i8x16, <)
     }
 
     #[doc(alias = "i16x8.min_s")]
     pub fn i16x8_min_s(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, i16x8_min, i16, 8, as_i16x8, from_i16x8, <)
+        simd_minmax!(self, rhs, i16x8_min, as_i16x8, from_i16x8, <)
     }
 
     #[doc(alias = "i32x4.min_s")]
     pub fn i32x4_min_s(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, i32x4_min, i32, 4, as_i32x4, from_i32x4, <)
+        simd_minmax!(self, rhs, i32x4_min, as_i32x4, from_i32x4, <)
     }
 
     #[doc(alias = "i8x16.min_u")]
     pub fn i8x16_min_u(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, u8x16_min, u8, 16, as_u8x16, from_u8x16, <)
+        simd_minmax!(self, rhs, u8x16_min, as_u8x16, from_u8x16, <)
     }
 
     #[doc(alias = "i16x8.min_u")]
     pub fn i16x8_min_u(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, u16x8_min, u16, 8, as_u16x8, from_u16x8, <)
+        simd_minmax!(self, rhs, u16x8_min, as_u16x8, from_u16x8, <)
     }
 
     #[doc(alias = "i32x4.min_u")]
     pub fn i32x4_min_u(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, u32x4_min, u32, 4, as_u32x4, from_u32x4, <)
+        simd_minmax!(self, rhs, u32x4_min, as_u32x4, from_u32x4, <)
     }
 
     #[doc(alias = "i8x16.max_s")]
     pub fn i8x16_max_s(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, i8x16_max, i8, 16, as_i8x16, from_i8x16, >)
+        simd_minmax!(self, rhs, i8x16_max, as_i8x16, from_i8x16, >)
     }
 
     #[doc(alias = "i16x8.max_s")]
     pub fn i16x8_max_s(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, i16x8_max, i16, 8, as_i16x8, from_i16x8, >)
+        simd_minmax!(self, rhs, i16x8_max, as_i16x8, from_i16x8, >)
     }
 
     #[doc(alias = "i32x4.max_s")]
     pub fn i32x4_max_s(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, i32x4_max, i32, 4, as_i32x4, from_i32x4, >)
+        simd_minmax!(self, rhs, i32x4_max, as_i32x4, from_i32x4, >)
     }
 
     #[doc(alias = "i8x16.max_u")]
     pub fn i8x16_max_u(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, u8x16_max, u8, 16, as_u8x16, from_u8x16, >)
+        simd_minmax!(self, rhs, u8x16_max, as_u8x16, from_u8x16, >)
     }
 
     #[doc(alias = "i16x8.max_u")]
     pub fn i16x8_max_u(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, u16x8_max, u16, 8, as_u16x8, from_u16x8, >)
+        simd_minmax!(self, rhs, u16x8_max, as_u16x8, from_u16x8, >)
     }
 
     #[doc(alias = "i32x4.max_u")]
     pub fn i32x4_max_u(self, rhs: Self) -> Self {
-        simd_minmax!(self, rhs, u32x4_max, u32, 4, as_u32x4, from_u32x4, >)
+        simd_minmax!(self, rhs, u32x4_max, as_u32x4, from_u32x4, >)
     }
 
     #[doc(alias = "f32x4.eq")]
     pub fn f32x4_eq(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i32, 4, as_f32x4, from_i32x4, ==)
+        simd_cmp_mask!(generic self, rhs, as_f32x4, from_i32x4, ==)
     }
 
     #[doc(alias = "f64x2.eq")]
     pub fn f64x2_eq(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i64, 2, as_f64x2, from_i64x2, ==)
+        simd_cmp_mask!(generic self, rhs, as_f64x2, from_i64x2, ==)
     }
 
     #[doc(alias = "f32x4.ne")]
     pub fn f32x4_ne(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i32, 4, as_f32x4, from_i32x4, !=)
+        simd_cmp_mask!(generic self, rhs, as_f32x4, from_i32x4, !=)
     }
 
     #[doc(alias = "f64x2.ne")]
     pub fn f64x2_ne(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i64, 2, as_f64x2, from_i64x2, !=)
+        simd_cmp_mask!(generic self, rhs, as_f64x2, from_i64x2, !=)
     }
 
     #[doc(alias = "f32x4.lt")]
     pub fn f32x4_lt(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i32, 4, as_f32x4, from_i32x4, <)
+        simd_cmp_mask!(generic self, rhs, as_f32x4, from_i32x4, <)
     }
 
     #[doc(alias = "f64x2.lt")]
     pub fn f64x2_lt(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i64, 2, as_f64x2, from_i64x2, <)
+        simd_cmp_mask!(generic self, rhs, as_f64x2, from_i64x2, <)
     }
 
     #[doc(alias = "f32x4.gt")]
@@ -1132,172 +1095,172 @@ impl Value128 {
 
     #[doc(alias = "f32x4.le")]
     pub fn f32x4_le(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i32, 4, as_f32x4, from_i32x4, <=)
+        simd_cmp_mask!(generic self, rhs, as_f32x4, from_i32x4, <=)
     }
 
     #[doc(alias = "f64x2.le")]
     pub fn f64x2_le(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i64, 2, as_f64x2, from_i64x2, <=)
+        simd_cmp_mask!(generic self, rhs, as_f64x2, from_i64x2, <=)
     }
 
     #[doc(alias = "f32x4.ge")]
     pub fn f32x4_ge(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i32, 4, as_f32x4, from_i32x4, >=)
+        simd_cmp_mask!(generic self, rhs, as_f32x4, from_i32x4, >=)
     }
 
     #[doc(alias = "f64x2.ge")]
     pub fn f64x2_ge(self, rhs: Self) -> Self {
-        simd_cmp_mask_const!(self, rhs, i64, 2, as_f64x2, from_i64x2, >=)
+        simd_cmp_mask!(generic self, rhs, as_f64x2, from_i64x2, >=)
     }
 
     #[doc(alias = "f32x4.ceil")]
     pub fn f32x4_ceil(self) -> Self {
-        simd_float_unary!(self, map_f32x4, |x| canonicalize_simd_f32_nan(x.ceil()))
+        self.map_f32x4(|x| canonicalize_simd_f32_nan(x.ceil()))
     }
 
     #[doc(alias = "f64x2.ceil")]
     pub fn f64x2_ceil(self) -> Self {
-        simd_float_unary!(self, map_f64x2, |x| canonicalize_simd_f64_nan(x.ceil()))
+        self.map_f64x2(|x| canonicalize_simd_f64_nan(x.ceil()))
     }
 
     #[doc(alias = "f32x4.floor")]
     pub fn f32x4_floor(self) -> Self {
-        simd_float_unary!(self, map_f32x4, |x| canonicalize_simd_f32_nan(x.floor()))
+        self.map_f32x4(|x| canonicalize_simd_f32_nan(x.floor()))
     }
 
     #[doc(alias = "f64x2.floor")]
     pub fn f64x2_floor(self) -> Self {
-        simd_float_unary!(self, map_f64x2, |x| canonicalize_simd_f64_nan(x.floor()))
+        self.map_f64x2(|x| canonicalize_simd_f64_nan(x.floor()))
     }
 
     #[doc(alias = "f32x4.trunc")]
     pub fn f32x4_trunc(self) -> Self {
-        simd_float_unary!(self, map_f32x4, |x| canonicalize_simd_f32_nan(x.trunc()))
+        self.map_f32x4(|x| canonicalize_simd_f32_nan(x.trunc()))
     }
 
     #[doc(alias = "f64x2.trunc")]
     pub fn f64x2_trunc(self) -> Self {
-        simd_float_unary!(self, map_f64x2, |x| canonicalize_simd_f64_nan(x.trunc()))
+        self.map_f64x2(|x| canonicalize_simd_f64_nan(x.trunc()))
     }
 
     #[doc(alias = "f32x4.nearest")]
     pub fn f32x4_nearest(self) -> Self {
-        simd_float_unary!(self, map_f32x4, |x| canonicalize_simd_f32_nan(TinywasmFloatExt::tw_nearest(x)))
+        self.map_f32x4(|x| canonicalize_simd_f32_nan(TinywasmFloatExt::tw_nearest(x)))
     }
 
     #[doc(alias = "f64x2.nearest")]
     pub fn f64x2_nearest(self) -> Self {
-        simd_float_unary!(self, map_f64x2, |x| canonicalize_simd_f64_nan(TinywasmFloatExt::tw_nearest(x)))
+        self.map_f64x2(|x| canonicalize_simd_f64_nan(TinywasmFloatExt::tw_nearest(x)))
     }
 
     #[doc(alias = "f32x4.abs")]
     pub fn f32x4_abs(self) -> Self {
-        simd_float_unary!(self, map_f32x4, f32::abs)
+        self.map_f32x4(f32::abs)
     }
 
     #[doc(alias = "f64x2.abs")]
     pub fn f64x2_abs(self) -> Self {
-        simd_float_unary!(self, map_f64x2, f64::abs)
+        self.map_f64x2(f64::abs)
     }
 
     #[doc(alias = "f32x4.neg")]
     pub fn f32x4_neg(self) -> Self {
-        simd_float_unary!(self, map_f32x4, |x| -x)
+        self.map_f32x4(|x| -x)
     }
 
     #[doc(alias = "f64x2.neg")]
     pub fn f64x2_neg(self) -> Self {
-        simd_float_unary!(self, map_f64x2, |x| -x)
+        self.map_f64x2(|x| -x)
     }
 
     #[doc(alias = "f32x4.sqrt")]
     pub fn f32x4_sqrt(self) -> Self {
-        simd_float_unary!(self, map_f32x4, |x| canonicalize_simd_f32_nan(x.sqrt()))
+        self.map_f32x4(|x| canonicalize_simd_f32_nan(x.sqrt()))
     }
 
     #[doc(alias = "f64x2.sqrt")]
     pub fn f64x2_sqrt(self) -> Self {
-        simd_float_unary!(self, map_f64x2, |x| canonicalize_simd_f64_nan(x.sqrt()))
+        self.map_f64x2(|x| canonicalize_simd_f64_nan(x.sqrt()))
     }
 
     #[doc(alias = "f32x4.add")]
     pub fn f32x4_add(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f32x4, |a, b| canonicalize_simd_f32_nan(a + b))
+        self.zip_f32x4(rhs, |a, b| canonicalize_simd_f32_nan(a + b))
     }
 
     #[doc(alias = "f64x2.add")]
     pub fn f64x2_add(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f64x2, |a, b| canonicalize_simd_f64_nan(a + b))
+        self.zip_f64x2(rhs, |a, b| canonicalize_simd_f64_nan(a + b))
     }
 
     #[doc(alias = "f32x4.sub")]
     pub fn f32x4_sub(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f32x4, |a, b| canonicalize_simd_f32_nan(a - b))
+        self.zip_f32x4(rhs, |a, b| canonicalize_simd_f32_nan(a - b))
     }
 
     #[doc(alias = "f64x2.sub")]
     pub fn f64x2_sub(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f64x2, |a, b| canonicalize_simd_f64_nan(a - b))
+        self.zip_f64x2(rhs, |a, b| canonicalize_simd_f64_nan(a - b))
     }
 
     #[doc(alias = "f32x4.mul")]
     pub fn f32x4_mul(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f32x4, |a, b| canonicalize_simd_f32_nan(a * b))
+        self.zip_f32x4(rhs, |a, b| canonicalize_simd_f32_nan(a * b))
     }
 
     #[doc(alias = "f64x2.mul")]
     pub fn f64x2_mul(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f64x2, |a, b| canonicalize_simd_f64_nan(a * b))
+        self.zip_f64x2(rhs, |a, b| canonicalize_simd_f64_nan(a * b))
     }
 
     #[doc(alias = "f32x4.div")]
     pub fn f32x4_div(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f32x4, |a, b| canonicalize_simd_f32_nan(a / b))
+        self.zip_f32x4(rhs, |a, b| canonicalize_simd_f32_nan(a / b))
     }
 
     #[doc(alias = "f64x2.div")]
     pub fn f64x2_div(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f64x2, |a, b| canonicalize_simd_f64_nan(a / b))
+        self.zip_f64x2(rhs, |a, b| canonicalize_simd_f64_nan(a / b))
     }
 
     #[doc(alias = "f32x4.min")]
     pub fn f32x4_min(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f32x4, TinywasmFloatExt::tw_minimum)
+        self.zip_f32x4(rhs, TinywasmFloatExt::tw_minimum)
     }
 
     #[doc(alias = "f64x2.min")]
     pub fn f64x2_min(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f64x2, TinywasmFloatExt::tw_minimum)
+        self.zip_f64x2(rhs, TinywasmFloatExt::tw_minimum)
     }
 
     #[doc(alias = "f32x4.max")]
     pub fn f32x4_max(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f32x4, TinywasmFloatExt::tw_maximum)
+        self.zip_f32x4(rhs, TinywasmFloatExt::tw_maximum)
     }
 
     #[doc(alias = "f64x2.max")]
     pub fn f64x2_max(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f64x2, TinywasmFloatExt::tw_maximum)
+        self.zip_f64x2(rhs, TinywasmFloatExt::tw_maximum)
     }
 
     #[doc(alias = "f32x4.pmin")]
     pub fn f32x4_pmin(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f32x4, |a, b| if b < a { b } else { a })
+        self.zip_f32x4(rhs, |a, b| if b < a { b } else { a })
     }
 
     #[doc(alias = "f64x2.pmin")]
     pub fn f64x2_pmin(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f64x2, |a, b| if b < a { b } else { a })
+        self.zip_f64x2(rhs, |a, b| if b < a { b } else { a })
     }
 
     #[doc(alias = "f32x4.pmax")]
     pub fn f32x4_pmax(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f32x4, |a, b| if b > a { b } else { a })
+        self.zip_f32x4(rhs, |a, b| if b > a { b } else { a })
     }
 
     #[doc(alias = "f64x2.pmax")]
     pub fn f64x2_pmax(self, rhs: Self) -> Self {
-        simd_float_binary!(self, rhs, zip_f64x2, |a, b| if b > a { b } else { a })
+        self.zip_f64x2(rhs, |a, b| if b > a { b } else { a })
     }
 
     #[doc(alias = "f32x4.relaxed_madd")]
@@ -1366,24 +1329,12 @@ impl Value128 {
 
     #[doc(alias = "i32x4.trunc_sat_f32x4_s")]
     pub fn i32x4_trunc_sat_f32x4_s(self) -> Self {
-        let v = self.as_f32x4();
-        Self::from_i32x4([
-            trunc_sat_f32_to_i32(v[0]),
-            trunc_sat_f32_to_i32(v[1]),
-            trunc_sat_f32_to_i32(v[2]),
-            trunc_sat_f32_to_i32(v[3]),
-        ])
+        Self::from_i32x4(self.as_f32x4().map(trunc_sat_f32_to_i32))
     }
 
     #[doc(alias = "i32x4.trunc_sat_f32x4_u")]
     pub fn i32x4_trunc_sat_f32x4_u(self) -> Self {
-        let v = self.as_f32x4();
-        Self::from_u32x4([
-            trunc_sat_f32_to_u32(v[0]),
-            trunc_sat_f32_to_u32(v[1]),
-            trunc_sat_f32_to_u32(v[2]),
-            trunc_sat_f32_to_u32(v[3]),
-        ])
+        Self::from_u32x4(self.as_f32x4().map(trunc_sat_f32_to_u32))
     }
 
     #[doc(alias = "i32x4.trunc_sat_f64x2_s_zero")]
@@ -1400,38 +1351,36 @@ impl Value128 {
 
     #[doc(alias = "f32x4.convert_i32x4_s")]
     pub fn f32x4_convert_i32x4_s(self) -> Self {
-        let v = self.as_i32x4();
-        Self::from_f32x4([v[0] as f32, v[1] as f32, v[2] as f32, v[3] as f32])
+        Self::from_f32x4(self.as_i32x4().map(|x| x as f32))
     }
 
     #[doc(alias = "f32x4.convert_i32x4_u")]
     pub fn f32x4_convert_i32x4_u(self) -> Self {
-        let v = self.as_u32x4();
-        Self::from_f32x4([v[0] as f32, v[1] as f32, v[2] as f32, v[3] as f32])
+        Self::from_f32x4(self.as_u32x4().map(|x| x as f32))
     }
 
     #[doc(alias = "f64x2.convert_low_i32x4_s")]
     pub fn f64x2_convert_low_i32x4_s(self) -> Self {
-        let v = self.as_i32x4();
-        Self::from_f64x2([v[0] as f64, v[1] as f64])
+        let [a, b, ..] = self.as_i32x4();
+        Self::from_f64x2([a as f64, b as f64])
     }
 
     #[doc(alias = "f64x2.convert_low_i32x4_u")]
     pub fn f64x2_convert_low_i32x4_u(self) -> Self {
-        let v = self.as_u32x4();
-        Self::from_f64x2([v[0] as f64, v[1] as f64])
+        let [a, b, ..] = self.as_u32x4();
+        Self::from_f64x2([a as f64, b as f64])
     }
 
     #[doc(alias = "f32x4.demote_f64x2_zero")]
     pub fn f32x4_demote_f64x2_zero(self) -> Self {
-        let v = self.as_f64x2();
-        Self::from_f32x4([v[0] as f32, v[1] as f32, 0.0, 0.0])
+        let [a, b] = self.as_f64x2();
+        Self::from_f32x4([a as f32, b as f32, 0.0, 0.0])
     }
 
     #[doc(alias = "f64x2.promote_low_f32x4")]
     pub fn f64x2_promote_low_f32x4(self) -> Self {
-        let v = self.as_f32x4();
-        Self::from_f64x2([v[0] as f64, v[1] as f64])
+        let [a, b, ..] = self.as_f32x4();
+        Self::from_f64x2([a as f64, b as f64])
     }
 
     #[doc(alias = "i16x8.splat")]
@@ -1473,22 +1422,22 @@ impl Value128 {
 
     #[doc(alias = "i16x8.extract_lane_s")]
     pub fn extract_lane_i16(self, lane: u8) -> i16 {
-        i16::from_le_bytes(self.extract_lane_bytes::<2>(lane, 8))
+        i16::from_le_bytes(self.extract_lane_bytes::<2, 8>(lane))
     }
 
     #[doc(alias = "i16x8.extract_lane_u")]
     pub fn extract_lane_u16(self, lane: u8) -> u16 {
-        u16::from_le_bytes(self.extract_lane_bytes::<2>(lane, 8))
+        u16::from_le_bytes(self.extract_lane_bytes::<2, 8>(lane))
     }
 
     #[doc(alias = "i32x4.extract_lane")]
     pub fn extract_lane_i32(self, lane: u8) -> i32 {
-        i32::from_le_bytes(self.extract_lane_bytes::<4>(lane, 4))
+        i32::from_le_bytes(self.extract_lane_bytes::<4, 4>(lane))
     }
 
     #[doc(alias = "i64x2.extract_lane")]
     pub fn extract_lane_i64(self, lane: u8) -> i64 {
-        i64::from_le_bytes(self.extract_lane_bytes::<8>(lane, 2))
+        i64::from_le_bytes(self.extract_lane_bytes::<8, 2>(lane))
     }
 
     #[doc(alias = "f32x4.extract_lane")]
diff --git a/crates/tinywasm/src/interpreter/simd/macros.rs b/crates/tinywasm/src/interpreter/simd/macros.rs
index 98ac1c7..7831586 100644
--- a/crates/tinywasm/src/interpreter/simd/macros.rs
+++ b/crates/tinywasm/src/interpreter/simd/macros.rs
@@ -1,23 +1,5 @@
 #![allow(unused_macros)]
 
-macro_rules! target_simd_x86 {
-    () => {
-        all(
-            feature = "simd-x86",
-            target_arch = "x86_64",
-            target_feature = "sse4.2",
-            target_feature = "avx",
-            target_feature = "avx2",
-            target_feature = "bmi1",
-            target_feature = "bmi2",
-            target_feature = "fma",
-            target_feature = "lzcnt",
-            target_feature = "movbe",
-            target_feature = "popcnt",
-        )
-    };
-}
-
 macro_rules! simd_impl {
     ($(wasm => $wasm:block)? $(x86 => $x86:block)? generic => $generic:block) => {
         cfg_select! {
@@ -32,229 +14,106 @@ macro_rules! simd_impl {
     (@pick_x86 ; $generic:block) => { $generic };
 }
 
-macro_rules! simd_wrapping_binop_generic {
-    ($lhs:expr, $rhs:expr, $lane_ty:ty, $lane_count:expr, $as_lanes:ident, $from_lanes:ident, $op:ident) => {{
-        let a = $lhs.$as_lanes();
-        let b = $rhs.$as_lanes();
-        let mut out = [0 as $lane_ty; $lane_count];
-        for ((dst, lhs), rhs) in out.iter_mut().zip(a).zip(b) {
-            *dst = lhs.$op(rhs);
-        }
-        Self::$from_lanes(out)
-    }};
-}
-
-macro_rules! simd_wrapping_binop {
-    ($lhs:expr, $rhs:expr, $wasm_op:ident, $lane_ty:ty, $lane_count:expr, $as_lanes:ident, $from_lanes:ident, $op:ident) => {{
+macro_rules! simd_binop {
+    ($lhs:expr, $rhs:expr, $wasm_op:ident, $as_lanes:ident, $from_lanes:ident, $op:ident) => {{
         simd_impl! {
             wasm => { Self::from_wasm_v128(wasm::$wasm_op($lhs.to_wasm_v128(), $rhs.to_wasm_v128())) }
-            generic => { simd_wrapping_binop_generic!($lhs, $rhs, $lane_ty, $lane_count, $as_lanes, $from_lanes, $op) }
-        }
-    }};
-}
-
-macro_rules! simd_sat_binop_generic {
-    ($lhs:expr, $rhs:expr, $lane_ty:ty, $lane_count:expr, $as_lanes:ident, $from_lanes:ident, $op:ident) => {{
-        let a = $lhs.$as_lanes();
-        let b = $rhs.$as_lanes();
-        let mut out = [0 as $lane_ty; $lane_count];
-        for ((dst, lhs), rhs) in out.iter_mut().zip(a).zip(b) {
-            *dst = lhs.$op(rhs);
-        }
-        Self::$from_lanes(out)
-    }};
-}
-
-macro_rules! simd_sat_binop {
-    ($lhs:expr, $rhs:expr, $wasm_op:ident, $lane_ty:ty, $lane_count:expr, $as_lanes:ident, $from_lanes:ident, $op:ident) => {{
-        simd_impl! {
-            wasm => { Self::from_wasm_v128(wasm::$wasm_op($lhs.to_wasm_v128(), $rhs.to_wasm_v128())) }
-            generic => { simd_sat_binop_generic!($lhs, $rhs, $lane_ty, $lane_count, $as_lanes, $from_lanes, $op) }
+            generic => {
+                let a = $lhs.$as_lanes();
+                let b = $rhs.$as_lanes();
+                Self::$from_lanes(core::array::from_fn(|i| a[i].$op(b[i])))
+            }
         }
     }};
 }
 
-macro_rules! simd_shift_left {
-    ($value:expr, $shift:expr, $lane_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident, $mask:expr) => {{
+macro_rules! simd_shift {
+    ($value:expr, $shift:expr, $as_lanes:ident, $from_lanes:ident, $mask:expr, shl) => {{
         let lanes = $value.$as_lanes();
         let s = $shift & $mask;
-        let mut out = [0 as $lane_ty; $count];
-        for (dst, lane) in out.iter_mut().zip(lanes) {
-            *dst = lane.wrapping_shl(s);
-        }
-        Self::$from_lanes(out)
+        Self::$from_lanes(core::array::from_fn(|i| lanes[i].wrapping_shl(s)))
     }};
-}
-
-macro_rules! simd_shift_right {
-    ($value:expr, $shift:expr, $lane_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident, $mask:expr) => {{
+    ($value:expr, $shift:expr, $as_lanes:ident, $from_lanes:ident, $mask:expr, shr) => {{
         let lanes = $value.$as_lanes();
         let s = $shift & $mask;
-        let mut out = [0 as $lane_ty; $count];
-        for (dst, lane) in out.iter_mut().zip(lanes) {
-            *dst = lane >> s;
-        }
-        Self::$from_lanes(out)
-    }};
-}
-
-macro_rules! simd_avgr_u_generic {
-    ($lhs:expr, $rhs:expr, $lane_ty:ty, $wide_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident) => {{
-        let a = $lhs.$as_lanes();
-        let b = $rhs.$as_lanes();
-        let mut out = [0 as $lane_ty; $count];
-        for ((dst, lhs), rhs) in out.iter_mut().zip(a).zip(b) {
-            *dst = ((lhs as $wide_ty + rhs as $wide_ty + 1) >> 1) as $lane_ty;
-        }
-        Self::$from_lanes(out)
+        Self::$from_lanes(core::array::from_fn(|i| lanes[i] >> s))
     }};
 }
 
 macro_rules! simd_avgr_u {
-    ($lhs:expr, $rhs:expr, $wasm_op:ident, $lane_ty:ty, $wide_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident) => {{
+    ($lhs:expr, $rhs:expr, $wasm_op:ident, $lane_ty:ty, $wide_ty:ty, $as_lanes:ident, $from_lanes:ident) => {{
         simd_impl! {
             wasm => { Self::from_wasm_v128(wasm::$wasm_op($lhs.to_wasm_v128(), $rhs.to_wasm_v128())) }
-            generic => { simd_avgr_u_generic!($lhs, $rhs, $lane_ty, $wide_ty, $count, $as_lanes, $from_lanes) }
+            generic => {
+                let a = $lhs.$as_lanes();
+                let b = $rhs.$as_lanes();
+                Self::$from_lanes(core::array::from_fn(|i| ((a[i] as $wide_ty + b[i] as $wide_ty + 1) >> 1) as $lane_ty))
+            }
         }
     }};
 }
 
 macro_rules! simd_extend_cast {
-    ($value:expr, $src_as:ident, $dst_from:ident, $dst_ty:ty, $dst_count:expr, $offset:expr) => {{
+    ($value:expr, $src_as:ident, $dst_from:ident, $dst_ty:ty, $offset:expr) => {{
         let lanes = $value.$src_as();
-        let mut out = [0 as $dst_ty; $dst_count];
-        for (dst, src) in out.iter_mut().zip(lanes[$offset..($offset + $dst_count)].iter()) {
-            *dst = *src as $dst_ty;
-        }
-        Self::$dst_from(out)
+        Self::$dst_from(core::array::from_fn(|i| lanes[$offset + i] as $dst_ty))
     }};
 }
 
-macro_rules! simd_extmul_signed {
-    ($lhs:expr, $rhs:expr, $src_as:ident, $dst_from:ident, $dst_ty:ty, $dst_count:expr, $offset:expr) => {{
+macro_rules! simd_extmul {
+    ($lhs:expr, $rhs:expr, $src_as:ident, $dst_from:ident, $dst_ty:ty, $offset:expr) => {{
         let a = $lhs.$src_as();
         let b = $rhs.$src_as();
-        let mut out = [0 as $dst_ty; $dst_count];
-        for ((dst, lhs), rhs) in
-            out.iter_mut().zip(a[$offset..($offset + $dst_count)].iter()).zip(b[$offset..($offset + $dst_count)].iter())
-        {
-            *dst = (*lhs as $dst_ty).wrapping_mul(*rhs as $dst_ty);
-        }
-        Self::$dst_from(out)
+        Self::$dst_from(core::array::from_fn(|i| (a[$offset + i] as $dst_ty).wrapping_mul(b[$offset + i] as $dst_ty)))
     }};
 }
 
-macro_rules! simd_extmul_unsigned {
-    ($lhs:expr, $rhs:expr, $src_as:ident, $dst_from:ident, $dst_ty:ty, $dst_count:expr, $offset:expr) => {{
-        let a = $lhs.$src_as();
-        let b = $rhs.$src_as();
-        let mut out = [0 as $dst_ty; $dst_count];
-        for ((dst, lhs), rhs) in
-            out.iter_mut().zip(a[$offset..($offset + $dst_count)].iter()).zip(b[$offset..($offset + $dst_count)].iter())
-        {
-            *dst = (*lhs as $dst_ty) * (*rhs as $dst_ty);
-        }
-        Self::$dst_from(out)
-    }};
-}
-
-macro_rules! simd_cmp_mask_generic {
-    ($lhs:expr, $rhs:expr, $out_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident, $cmp:tt) => {{
+macro_rules! simd_cmp_mask {
+    (generic $lhs:expr, $rhs:expr, $as_lanes:ident, $from_lanes:ident, $cmp:tt) => {{
         let a = $lhs.$as_lanes();
         let b = $rhs.$as_lanes();
-        let mut out = [0 as $out_ty; $count];
-        for ((dst, lhs), rhs) in out.iter_mut().zip(a).zip(b) {
-            *dst = if lhs $cmp rhs { -1 } else { 0 };
-        }
-        Self::$from_lanes(out)
+        Self::$from_lanes(core::array::from_fn(|i| if a[i] $cmp b[i] { -1 } else { 0 }))
     }};
-}
-
-macro_rules! simd_cmp_mask {
-    ($lhs:expr, $rhs:expr, $wasm_op:ident, $out_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident, $cmp:tt) => {{
+    ($lhs:expr, $rhs:expr, $wasm_op:ident, $as_lanes:ident, $from_lanes:ident, $cmp:tt) => {{
         simd_impl! {
             wasm => { Self::from_wasm_v128(wasm::$wasm_op($lhs.to_wasm_v128(), $rhs.to_wasm_v128())) }
-            generic => { simd_cmp_mask_generic!($lhs, $rhs, $out_ty, $count, $as_lanes, $from_lanes, $cmp) }
+            generic => { simd_cmp_mask!(generic $lhs, $rhs, $as_lanes, $from_lanes, $cmp) }
         }
     }};
 }
 
-macro_rules! simd_cmp_mask_const {
-    ($lhs:expr, $rhs:expr, $out_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident, $cmp:tt) => {{
-        let a = $lhs.$as_lanes();
-        let b = $rhs.$as_lanes();
-        let mut out = [0 as $out_ty; $count];
-        for ((dst, lhs), rhs) in out.iter_mut().zip(a).zip(b) {
-            *dst = if lhs $cmp rhs { -1 } else { 0 };
-        }
-        Self::$from_lanes(out)
-    }};
-}
-
-macro_rules! simd_cmp_delegate {
-    ($lhs:expr, $rhs:expr, $delegate:ident) => {{ $rhs.$delegate($lhs) }};
-}
-
 macro_rules! simd_abs_const {
-    ($value:expr, $lane_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident) => {{
-        let a = $value.$as_lanes();
-        let mut out = [0 as $lane_ty; $count];
-        for (dst, lane) in out.iter_mut().zip(a) {
-            *dst = lane.wrapping_abs();
-        }
-        Self::$from_lanes(out)
-    }};
-}
-
-macro_rules! simd_neg_generic {
-    ($value:expr, $lane_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident) => {{
+    ($value:expr, $as_lanes:ident, $from_lanes:ident) => {{
         let a = $value.$as_lanes();
-        let mut out = [0 as $lane_ty; $count];
-        for (dst, lane) in out.iter_mut().zip(a) {
-            *dst = lane.wrapping_neg();
-        }
-        Self::$from_lanes(out)
+        Self::$from_lanes(core::array::from_fn(|i| a[i].wrapping_abs()))
     }};
 }
 
 macro_rules! simd_neg {
-    ($value:expr, $wasm_op:ident, $lane_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident) => {{
+    ($value:expr, $wasm_op:ident, $as_lanes:ident, $from_lanes:ident) => {{
         simd_impl! {
             wasm => { Self::from_wasm_v128(wasm::$wasm_op($value.to_wasm_v128())) }
-            generic => { simd_neg_generic!($value, $lane_ty, $count, $as_lanes, $from_lanes) }
-        }
-    }};
-}
-
-macro_rules! simd_minmax_generic {
-    ($lhs:expr, $rhs:expr, $lane_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident, $cmp:tt) => {{
-        let a = $lhs.$as_lanes();
-        let b = $rhs.$as_lanes();
-        let mut out = [0 as $lane_ty; $count];
-        for ((dst, lhs), rhs) in out.iter_mut().zip(a).zip(b) {
-            *dst = if lhs $cmp rhs { lhs } else { rhs };
+            generic => {
+                let a = $value.$as_lanes();
+                Self::$from_lanes(core::array::from_fn(|i| a[i].wrapping_neg()))
+            }
         }
-        Self::$from_lanes(out)
     }};
 }
 
 macro_rules! simd_minmax {
-    ($lhs:expr, $rhs:expr, $wasm_op:ident, $lane_ty:ty, $count:expr, $as_lanes:ident, $from_lanes:ident, $cmp:tt) => {{
+    ($lhs:expr, $rhs:expr, $wasm_op:ident, $as_lanes:ident, $from_lanes:ident, $cmp:tt) => {{
         simd_impl! {
             wasm => { Self::from_wasm_v128(wasm::$wasm_op($lhs.to_wasm_v128(), $rhs.to_wasm_v128())) }
-            generic => { simd_minmax_generic!($lhs, $rhs, $lane_ty, $count, $as_lanes, $from_lanes, $cmp) }
+            generic => {
+                let a = $lhs.$as_lanes();
+                let b = $rhs.$as_lanes();
+                Self::$from_lanes(core::array::from_fn(|i| if a[i] $cmp b[i] { a[i] } else { b[i] }))
+            }
         }
     }};
 }
 
-macro_rules! simd_float_unary {
-    ($value:expr, $map:ident, $op:expr) => {{ $value.$map($op) }};
-}
-
-macro_rules! simd_float_binary {
-    ($lhs:expr, $rhs:expr, $zip:ident, $op:expr) => {{ $lhs.$zip($rhs, $op) }};
-}
-
 #[rustfmt::skip]
 macro_rules! lane_read {
     (i8,  $bytes:expr, $offset:expr) => { $bytes[$offset] as i8 };
@@ -284,10 +143,11 @@ macro_rules! lane_write {
 }
 
 macro_rules! impl_lane_accessors {
-    ($( $as_vis:vis $as_name:ident => $from_vis:vis $from_name:ident : $lane_ty:tt, $lane_count:expr, $lane_bytes:expr; )*) => {
+    ($($as_vis:vis $as_name:ident => $from_vis:vis $from_name:ident: $lane_ty:tt, $lane_count:expr, $lane_bytes:expr;)*) => {
         $(
             #[inline]
             $as_vis const fn $as_name(self) -> [$lane_ty; $lane_count] {
+                const { assert!($lane_count * $lane_bytes == 16); };
                 let bytes = self.0;
                 let mut out = [0 as $lane_ty; $lane_count];
                 let mut i = 0;
@@ -300,13 +160,16 @@ macro_rules! impl_lane_accessors {
 
             #[inline]
             $from_vis const fn $from_name(lanes: [$lane_ty; $lane_count]) -> Self {
+                const { assert!($lane_count * $lane_bytes == 16); };
+
                 let mut bytes = [0u8; 16];
                 let mut i = 0;
                 while i < $lane_count {
+                    let offset = i * $lane_bytes;
                     let lane = lane_write!($lane_ty, lanes[i]);
                     let mut j = 0;
                     while j < $lane_bytes {
-                        bytes[i * $lane_bytes + j] = lane[j];
+                        bytes[offset + j] = lane[j];
                         j += 1;
                     }
                     i += 1;
diff --git a/crates/tinywasm/src/interpreter/simd/mod.rs b/crates/tinywasm/src/interpreter/simd/mod.rs
index e6784d7..b05769c 100644
--- a/crates/tinywasm/src/interpreter/simd/mod.rs
+++ b/crates/tinywasm/src/interpreter/simd/mod.rs
@@ -79,54 +79,27 @@ impl Value128 {
 
     #[inline]
     fn map_f32x4(self, mut op: impl FnMut(f32) -> f32) -> Self {
-        let bytes = self.0;
-        let mut out_bytes = [0u8; 16];
-        for (src, dst) in bytes.chunks_exact(4).zip(out_bytes.chunks_exact_mut(4)) {
-            let lane = f32::from_bits(u32::from_le_bytes([src[0], src[1], src[2], src[3]]));
-            dst.copy_from_slice(&op(lane).to_bits().to_le_bytes());
-        }
-        Self(out_bytes)
+        let [a, b, c, d] = self.as_f32x4();
+        Self::from_f32x4([op(a), op(b), op(c), op(d)])
     }
 
     #[inline]
     fn zip_f32x4(self, rhs: Self, mut op: impl FnMut(f32, f32) -> f32) -> Self {
-        let a_bytes = self.0;
-        let b_bytes = rhs.0;
-        let mut out_bytes = [0u8; 16];
-
-        for ((a, b), dst) in a_bytes.chunks_exact(4).zip(b_bytes.chunks_exact(4)).zip(out_bytes.chunks_exact_mut(4)) {
-            let a_lane = f32::from_bits(u32::from_le_bytes([a[0], a[1], a[2], a[3]]));
-            let b_lane = f32::from_bits(u32::from_le_bytes([b[0], b[1], b[2], b[3]]));
-            dst.copy_from_slice(&op(a_lane, b_lane).to_bits().to_le_bytes());
-        }
-
-        Self(out_bytes)
+        let [a0, a1, a2, a3] = self.as_f32x4();
+        let [b0, b1, b2, b3] = rhs.as_f32x4();
+        Self::from_f32x4([op(a0, b0), op(a1, b1), op(a2, b2), op(a3, b3)])
     }
 
     #[inline]
     fn map_f64x2(self, mut op: impl FnMut(f64) -> f64) -> Self {
-        let bytes = self.0;
-        let mut out_bytes = [0u8; 16];
-        for (src, dst) in bytes.chunks_exact(8).zip(out_bytes.chunks_exact_mut(8)) {
-            let lane =
-                f64::from_bits(u64::from_le_bytes([src[0], src[1], src[2], src[3], src[4], src[5], src[6], src[7]]));
-            dst.copy_from_slice(&op(lane).to_bits().to_le_bytes());
-        }
-        Self(out_bytes)
+        let [a, b] = self.as_f64x2();
+        Self::from_f64x2([op(a), op(b)])
     }
 
     #[inline]
     fn zip_f64x2(self, rhs: Self, mut op: impl FnMut(f64, f64) -> f64) -> Self {
-        let a_bytes = self.0;
-        let b_bytes = rhs.0;
-        let mut out_bytes = [0u8; 16];
-
-        for ((a, b), dst) in a_bytes.chunks_exact(8).zip(b_bytes.chunks_exact(8)).zip(out_bytes.chunks_exact_mut(8)) {
-            let a_lane = f64::from_bits(u64::from_le_bytes([a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]]));
-            let b_lane = f64::from_bits(u64::from_le_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]));
-            dst.copy_from_slice(&op(a_lane, b_lane).to_bits().to_le_bytes());
-        }
-
-        Self(out_bytes)
+        let [a0, a1] = self.as_f64x2();
+        let [b0, b1] = rhs.as_f64x2();
+        Self::from_f64x2([op(a0, b0), op(a1, b1)])
     }
 }
diff --git a/crates/tinywasm/src/interpreter/simd/utils.rs b/crates/tinywasm/src/interpreter/simd/utils.rs
index e02bac3..ebba815 100644
--- a/crates/tinywasm/src/interpreter/simd/utils.rs
+++ b/crates/tinywasm/src/interpreter/simd/utils.rs
@@ -4,22 +4,23 @@ use super::Value128;
 use crate::interpreter::no_std_floats::NoStdFloatExt;
 
 impl Value128 {
-    pub(super) fn extract_lane_bytes<const LANE_BYTES: usize>(self, lane: u8, lane_count: u8) -> [u8; LANE_BYTES] {
-        debug_assert!(lane < lane_count);
-        let bytes = self.0;
+    pub(super) fn extract_lane_bytes<const LANE_BYTES: usize, const LANE_COUNT: usize>(
+        self,
+        lane: u8,
+    ) -> [u8; LANE_BYTES] {
+        const { assert!(LANE_BYTES * LANE_COUNT == 16) };
+        assert!((lane as usize) < LANE_COUNT);
         let start = lane as usize * LANE_BYTES;
-        let mut out = [0u8; LANE_BYTES];
-        out.copy_from_slice(&bytes[start..start + LANE_BYTES]);
-        out
+        core::array::from_fn(|i| self.0[start + i])
     }
 
-    pub(super) fn replace_lane_bytes<const LANE_BYTES: usize>(
+    pub(super) fn replace_lane_bytes<const LANE_BYTES: usize, const LANE_COUNT: usize>(
         self,
         lane: u8,
         value: [u8; LANE_BYTES],
-        lane_count: u8,
     ) -> Self {
-        debug_assert!(lane < lane_count);
+        const { assert!(LANE_BYTES * LANE_COUNT == 16) };
+        assert!((lane as usize) < LANE_COUNT);
         let mut bytes = self.0;
         let start = lane as usize * LANE_BYTES;
         bytes[start..start + LANE_BYTES].copy_from_slice(&value);
diff --git a/crates/tinywasm/tests/generated/wasm-1.csv b/crates/tinywasm/tests/generated/wasm-1.csv
index dba7358..84273cf 100644
--- a/crates/tinywasm/tests/generated/wasm-1.csv
+++ b/crates/tinywasm/tests/generated/wasm-1.csv
@@ -6,3 +6,4 @@
 0.7.0,27572,335,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":162,"failed":0},{"name":"binary-leb128.wast","passed":91,"failed":0},{"name":"binary.wast","passed":112,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"bulk.wast","passed":75,"failed":42},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":170,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":98,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":900,"failed":0},{"name":"float_literals.wast","passed":179,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":441,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":186,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":79,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":96,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"ref_func.wast","passed":9,"failed":8},{"name":"ref_is_null.wast","passed":4,"failed":12},{"name":"ref_null.wast","passed":1,"failed":2},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1613,"failed":115},{"name":"table_fill.wast","passed":23,"failed":22},{"name":"table_get.wast","passed":10,"failed":6},{"name":"table_grow.wast","passed":21,"failed":29},{"name":"table_init.wast","passed":719,"failed":61},{"name":"table_set.wast","passed":19,"failed":7},{"name":"table_size.wast","passed":8,"failed":31},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}]
 0.8.0,20360,0,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":162,"failed":0},{"name":"binary-leb128.wast","passed":91,"failed":0},{"name":"binary.wast","passed":128,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":170,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":98,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":927,"failed":0},{"name":"float_literals.wast","passed":179,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":471,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":178,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":88,"failed":0},{"name":"memory_grow.wast","passed":104,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}]
 0.9.0,19241,0,[{"name":"address.wast","passed":243,"failed":0},{"name":"align.wast","passed":156,"failed":0},{"name":"binary-leb128.wast","passed":77,"failed":0},{"name":"binary.wast","passed":67,"failed":0},{"name":"block.wast","passed":171,"failed":0},{"name":"br.wast","passed":84,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":168,"failed":0},{"name":"break-drop.wast","passed":4,"failed":0},{"name":"call.wast","passed":82,"failed":0},{"name":"call_indirect.wast","passed":152,"failed":0},{"name":"comments.wast","passed":4,"failed":0},{"name":"const.wast","passed":668,"failed":0},{"name":"conversions.wast","passed":435,"failed":0},{"name":"custom.wast","passed":10,"failed":0},{"name":"data.wast","passed":45,"failed":0},{"name":"elem.wast","passed":55,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":82,"failed":0},{"name":"f32.wast","passed":2512,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2512,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":7,"failed":0},{"name":"float_exprs.wast","passed":900,"failed":0},{"name":"float_literals.wast","passed":161,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":441,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":121,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"globals.wast","passed":78,"failed":0},{"name":"i32.wast","passed":443,"failed":0},{"name":"i64.wast","passed":389,"failed":0},{"name":"if.wast","passed":151,"failed":0},{"name":"imports.wast","passed":146,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":116,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":81,"failed":0},{"name":"memory.wast","passed":71,"failed":0},{"name":"memory_grow.wast","passed":94,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":173,"failed":0},{"name":"names.wast","passed":483,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":111,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":5,"failed":0},{"name":"start.wast","passed":19,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"token.wast","passed":2,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":62,"failed":0},{"name":"unreached-invalid.wast","passed":110,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}]
+0.9.1,19241,0,[{"name":"address.wast","passed":243,"failed":0},{"name":"align.wast","passed":156,"failed":0},{"name":"binary-leb128.wast","passed":77,"failed":0},{"name":"binary.wast","passed":67,"failed":0},{"name":"block.wast","passed":171,"failed":0},{"name":"br.wast","passed":84,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":168,"failed":0},{"name":"break-drop.wast","passed":4,"failed":0},{"name":"call.wast","passed":82,"failed":0},{"name":"call_indirect.wast","passed":152,"failed":0},{"name":"comments.wast","passed":4,"failed":0},{"name":"const.wast","passed":668,"failed":0},{"name":"conversions.wast","passed":435,"failed":0},{"name":"custom.wast","passed":10,"failed":0},{"name":"data.wast","passed":45,"failed":0},{"name":"elem.wast","passed":55,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":82,"failed":0},{"name":"f32.wast","passed":2512,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2512,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":7,"failed":0},{"name":"float_exprs.wast","passed":900,"failed":0},{"name":"float_literals.wast","passed":161,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":441,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":121,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"globals.wast","passed":78,"failed":0},{"name":"i32.wast","passed":443,"failed":0},{"name":"i64.wast","passed":389,"failed":0},{"name":"if.wast","passed":151,"failed":0},{"name":"imports.wast","passed":146,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":116,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":81,"failed":0},{"name":"memory.wast","passed":71,"failed":0},{"name":"memory_grow.wast","passed":94,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":173,"failed":0},{"name":"names.wast","passed":483,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":111,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":5,"failed":0},{"name":"start.wast","passed":19,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"token.wast","passed":2,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":62,"failed":0},{"name":"unreached-invalid.wast","passed":110,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-2.csv b/crates/tinywasm/tests/generated/wasm-2.csv
index e9b68e3..b58d33e 100644
--- a/crates/tinywasm/tests/generated/wasm-2.csv
+++ b/crates/tinywasm/tests/generated/wasm-2.csv
@@ -11,3 +11,4 @@
 0.7.0,20278,0,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":162,"failed":0},{"name":"binary-leb128.wast","passed":91,"failed":0},{"name":"binary.wast","passed":112,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":170,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":98,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":900,"failed":0},{"name":"float_literals.wast","passed":179,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":441,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":186,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":79,"failed":0},{"name":"memory_grow.wast","passed":96,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}]
 0.8.0,28008,0,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":162,"failed":0},{"name":"binary-leb128.wast","passed":91,"failed":0},{"name":"binary.wast","passed":128,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"bulk.wast","passed":117,"failed":0},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":170,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":98,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":927,"failed":0},{"name":"float_literals.wast","passed":179,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":471,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":178,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":88,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":104,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"obsolete-keywords.wast","passed":11,"failed":0},{"name":"ref_func.wast","passed":17,"failed":0},{"name":"ref_is_null.wast","passed":16,"failed":0},{"name":"ref_null.wast","passed":3,"failed":0},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1728,"failed":0},{"name":"table_fill.wast","passed":45,"failed":0},{"name":"table_get.wast","passed":16,"failed":0},{"name":"table_grow.wast","passed":58,"failed":0},{"name":"table_init.wast","passed":780,"failed":0},{"name":"table_set.wast","passed":26,"failed":0},{"name":"table_size.wast","passed":39,"failed":0},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}]
 0.9.0,28008,0,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":162,"failed":0},{"name":"binary-leb128.wast","passed":89,"failed":0},{"name":"binary.wast","passed":128,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"bulk.wast","passed":117,"failed":0},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":172,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":98,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":927,"failed":0},{"name":"float_literals.wast","passed":179,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":471,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":178,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":88,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":104,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"obsolete-keywords.wast","passed":11,"failed":0},{"name":"ref_func.wast","passed":17,"failed":0},{"name":"ref_is_null.wast","passed":16,"failed":0},{"name":"ref_null.wast","passed":3,"failed":0},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1728,"failed":0},{"name":"table_fill.wast","passed":45,"failed":0},{"name":"table_get.wast","passed":16,"failed":0},{"name":"table_grow.wast","passed":58,"failed":0},{"name":"table_init.wast","passed":780,"failed":0},{"name":"table_set.wast","passed":26,"failed":0},{"name":"table_size.wast","passed":39,"failed":0},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}]
+0.9.1,28008,0,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":162,"failed":0},{"name":"binary-leb128.wast","passed":89,"failed":0},{"name":"binary.wast","passed":128,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"bulk.wast","passed":117,"failed":0},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":172,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":98,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":927,"failed":0},{"name":"float_literals.wast","passed":179,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":471,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":178,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":88,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":104,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"obsolete-keywords.wast","passed":11,"failed":0},{"name":"ref_func.wast","passed":17,"failed":0},{"name":"ref_is_null.wast","passed":16,"failed":0},{"name":"ref_null.wast","passed":3,"failed":0},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1728,"failed":0},{"name":"table_fill.wast","passed":45,"failed":0},{"name":"table_get.wast","passed":16,"failed":0},{"name":"table_grow.wast","passed":58,"failed":0},{"name":"table_init.wast","passed":780,"failed":0},{"name":"table_set.wast","passed":26,"failed":0},{"name":"table_size.wast","passed":39,"failed":0},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-annotations.csv b/crates/tinywasm/tests/generated/wasm-annotations.csv
index dbef165..44c0912 100644
--- a/crates/tinywasm/tests/generated/wasm-annotations.csv
+++ b/crates/tinywasm/tests/generated/wasm-annotations.csv
@@ -1,2 +1,3 @@
 0.8.0,142,0,[{"name":"annotations.wast","passed":74,"failed":0},{"name":"annotations/simd_lane.wast (skipped)","passed":0,"failed":0},{"name":"id.wast","passed":7,"failed":0},{"name":"token.wast","passed":61,"failed":0}]
 0.9.0,617,0,[{"name":"annotations.wast","passed":74,"failed":0},{"name":"id.wast","passed":7,"failed":0},{"name":"simd_lane.wast","passed":475,"failed":0},{"name":"token.wast","passed":61,"failed":0}]
+0.9.1,617,0,[{"name":"annotations.wast","passed":74,"failed":0},{"name":"id.wast","passed":7,"failed":0},{"name":"simd_lane.wast","passed":475,"failed":0},{"name":"token.wast","passed":61,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-custom-page-sizes.csv b/crates/tinywasm/tests/generated/wasm-custom-page-sizes.csv
index d524113..f8a62b1 100644
--- a/crates/tinywasm/tests/generated/wasm-custom-page-sizes.csv
+++ b/crates/tinywasm/tests/generated/wasm-custom-page-sizes.csv
@@ -1,2 +1,3 @@
 0.8.0,57,0,[{"name":"custom-page-sizes-invalid.wast","passed":22,"failed":0},{"name":"custom-page-sizes.wast","passed":35,"failed":0}]
 0.9.0,211,0,[{"name":"binary.wast","passed":127,"failed":0},{"name":"custom-page-sizes-invalid.wast","passed":23,"failed":0},{"name":"custom-page-sizes.wast","passed":45,"failed":0},{"name":"memory_max.wast","passed":8,"failed":0},{"name":"memory_max_i64.wast","passed":8,"failed":0}]
+0.9.1,211,0,[{"name":"binary.wast","passed":127,"failed":0},{"name":"custom-page-sizes-invalid.wast","passed":23,"failed":0},{"name":"custom-page-sizes.wast","passed":45,"failed":0},{"name":"memory_max.wast","passed":8,"failed":0},{"name":"memory_max_i64.wast","passed":8,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-extended-const.csv b/crates/tinywasm/tests/generated/wasm-extended-const.csv
index d3720dd..6d9aa23 100644
--- a/crates/tinywasm/tests/generated/wasm-extended-const.csv
+++ b/crates/tinywasm/tests/generated/wasm-extended-const.csv
@@ -1,2 +1,3 @@
 0.8.0,211,79,[{"name":"data.wast","passed":61,"failed":4},{"name":"elem.wast","passed":99,"failed":12},{"name":"global.wast","passed":51,"failed":63}]
 0.9.0,290,0,[{"name":"data.wast","passed":65,"failed":0},{"name":"elem.wast","passed":111,"failed":0},{"name":"global.wast","passed":114,"failed":0}]
+0.9.1,290,0,[{"name":"data.wast","passed":65,"failed":0},{"name":"elem.wast","passed":111,"failed":0},{"name":"global.wast","passed":114,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-memory64.csv b/crates/tinywasm/tests/generated/wasm-memory64.csv
index f32a846..bbb4fde 100644
--- a/crates/tinywasm/tests/generated/wasm-memory64.csv
+++ b/crates/tinywasm/tests/generated/wasm-memory64.csv
@@ -1,2 +1,3 @@
 0.8.0,15081,3214,[{"name":"address.wast","passed":260,"failed":0},{"name":"address0.wast","passed":92,"failed":0},{"name":"address1.wast","passed":127,"failed":0},{"name":"address64.wast","passed":0,"failed":242},{"name":"align.wast","passed":161,"failed":0},{"name":"align0.wast","passed":5,"failed":0},{"name":"align64.wast","passed":83,"failed":73},{"name":"annotations.wast","passed":74,"failed":0},{"name":"array_copy.wast","passed":4,"failed":31},{"name":"array_fill.wast","passed":3,"failed":14},{"name":"array_init_data.wast","passed":2,"failed":31},{"name":"array_init_elem.wast","passed":3,"failed":20},{"name":"binary-gc.wast","passed":1,"failed":0},{"name":"binary-leb128.wast","passed":92,"failed":1},{"name":"binary.wast","passed":124,"failed":0},{"name":"binary0.wast","passed":7,"failed":0},{"name":"br_if.wast","passed":119,"failed":0},{"name":"br_on_cast.wast","passed":6,"failed":31},{"name":"br_on_cast_fail.wast","passed":6,"failed":31},{"name":"br_on_non_null.wast","passed":1,"failed":9},{"name":"br_on_null.wast","passed":1,"failed":9},{"name":"br_table.wast","passed":24,"failed":162},{"name":"call_indirect.wast","passed":47,"failed":124},{"name":"call_ref.wast","passed":4,"failed":31},{"name":"data.wast","passed":59,"failed":6},{"name":"data0.wast","passed":7,"failed":0},{"name":"data1.wast","passed":14,"failed":0},{"name":"data_drop0.wast","passed":11,"failed":0},{"name":"elem.wast","passed":137,"failed":14},{"name":"endianness64.wast","passed":0,"failed":69},{"name":"exports.wast","passed":97,"failed":0},{"name":"exports0.wast","passed":8,"failed":0},{"name":"float_exprs0.wast","passed":14,"failed":0},{"name":"float_exprs1.wast","passed":3,"failed":0},{"name":"float_memory0.wast","passed":30,"failed":0},{"name":"float_memory64.wast","passed":0,"failed":90},{"name":"func.wast","passed":175,"failed":0},{"name":"id.wast","passed":7,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":99,"failed":82},{"name":"imports0.wast","passed":8,"failed":0},{"name":"imports1.wast","passed":5,"failed":0},{"name":"imports2.wast","passed":20,"failed":0},{"name":"imports3.wast","passed":10,"failed":0},{"name":"imports4.wast","passed":16,"failed":0},{"name":"linking.wast","passed":122,"failed":41},{"name":"linking0.wast","passed":6,"failed":0},{"name":"linking1.wast","passed":14,"failed":0},{"name":"linking2.wast","passed":11,"failed":0},{"name":"linking3.wast","passed":14,"failed":0},{"name":"load.wast","passed":118,"failed":0},{"name":"load0.wast","passed":3,"failed":0},{"name":"load1.wast","passed":18,"failed":0},{"name":"load2.wast","passed":38,"failed":0},{"name":"load64.wast","passed":59,"failed":38},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_init.wast","passed":10,"failed":0},{"name":"local_tee.wast","passed":98,"failed":0},{"name":"memory-multi.wast","passed":6,"failed":0},{"name":"memory.wast","passed":86,"failed":0},{"name":"memory64.wast","passed":10,"failed":53},{"name":"memory64/array.wast (skipped)","passed":0,"failed":0},{"name":"memory64/extern.wast (skipped)","passed":0,"failed":0},{"name":"memory64/global.wast (skipped)","passed":0,"failed":0},{"name":"memory64/i31.wast (skipped)","passed":0,"failed":0},{"name":"memory64/ref_null.wast (skipped)","passed":0,"failed":0},{"name":"memory64/select.wast (skipped)","passed":0,"failed":0},{"name":"memory64/simd_address.wast (skipped)","passed":0,"failed":0},{"name":"memory64/simd_lane.wast (skipped)","passed":0,"failed":0},{"name":"memory64/struct.wast (skipped)","passed":0,"failed":0},{"name":"memory64/table.wast (skipped)","passed":0,"failed":0},{"name":"memory_copy.wast","passed":8385,"failed":515},{"name":"memory_copy0.wast","passed":29,"failed":0},{"name":"memory_copy1.wast","passed":14,"failed":0},{"name":"memory_fill.wast","passed":164,"failed":36},{"name":"memory_fill0.wast","passed":16,"failed":0},{"name":"memory_grow.wast","passed":157,"failed":0},{"name":"memory_grow64.wast","passed":0,"failed":49},{"name":"memory_init.wast","passed":307,"failed":173},{"name":"memory_init0.wast","passed":13,"failed":0},{"name":"memory_redundancy64.wast","passed":0,"failed":8},{"name":"memory_size.wast","passed":49,"failed":0},{"name":"memory_size0.wast","passed":8,"failed":0},{"name":"memory_size1.wast","passed":15,"failed":0},{"name":"memory_size2.wast","passed":21,"failed":0},{"name":"memory_size3.wast","passed":2,"failed":0},{"name":"memory_trap0.wast","passed":14,"failed":0},{"name":"memory_trap1.wast","passed":168,"failed":0},{"name":"memory_trap64.wast","passed":0,"failed":172},{"name":"ref.wast","passed":12,"failed":1},{"name":"ref_as_non_null.wast","passed":1,"failed":6},{"name":"ref_cast.wast","passed":0,"failed":45},{"name":"ref_eq.wast","passed":6,"failed":83},{"name":"ref_is_null.wast","passed":2,"failed":20},{"name":"ref_test.wast","passed":0,"failed":71},{"name":"return_call.wast","passed":18,"failed":27},{"name":"return_call_indirect.wast","passed":31,"failed":45},{"name":"return_call_ref.wast","passed":11,"failed":40},{"name":"simd_memory-multi.wast","passed":0,"failed":1},{"name":"start0.wast","passed":9,"failed":0},{"name":"store.wast","passed":111,"failed":0},{"name":"store0.wast","passed":5,"failed":0},{"name":"store1.wast","passed":13,"failed":0},{"name":"table-sub.wast","passed":2,"failed":1},{"name":"table_copy.wast","passed":1742,"failed":30},{"name":"table_copy_mixed.wast","passed":3,"failed":1},{"name":"table_fill.wast","passed":9,"failed":71},{"name":"table_get.wast","passed":5,"failed":12},{"name":"table_grow.wast","passed":36,"failed":43},{"name":"table_init.wast","passed":588,"failed":288},{"name":"table_set.wast","passed":7,"failed":21},{"name":"table_size.wast","passed":2,"failed":38},{"name":"tag.wast","passed":1,"failed":8},{"name":"throw.wast","passed":3,"failed":10},{"name":"throw_ref.wast","passed":2,"failed":13},{"name":"token.wast","passed":61,"failed":0},{"name":"traps0.wast","passed":15,"failed":0},{"name":"try_table.wast","passed":11,"failed":51},{"name":"type-canon.wast","passed":0,"failed":2},{"name":"type-equivalence.wast","passed":12,"failed":20},{"name":"type-rec.wast","passed":6,"failed":14},{"name":"type-subtyping.wast","passed":16,"failed":86},{"name":"unreached-invalid.wast","passed":121,"failed":0},{"name":"unreached-valid.wast","passed":2,"failed":11}]
 0.9.0,1598,0,[{"name":"address.wast","passed":260,"failed":0},{"name":"address64.wast","passed":242,"failed":0},{"name":"align64.wast","passed":156,"failed":0},{"name":"binary-leb128.wast","passed":93,"failed":0},{"name":"binary.wast","passed":169,"failed":0},{"name":"endianness64.wast","passed":69,"failed":0},{"name":"float_memory64.wast","passed":90,"failed":0},{"name":"load64.wast","passed":97,"failed":0},{"name":"memory.wast","passed":79,"failed":0},{"name":"memory64.wast","passed":65,"failed":0},{"name":"memory_grow64.wast","passed":49,"failed":0},{"name":"memory_redundancy64.wast","passed":8,"failed":0},{"name":"memory_trap64.wast","passed":172,"failed":0},{"name":"simd_address.wast","passed":49,"failed":0}]
+0.9.1,1598,0,[{"name":"address.wast","passed":260,"failed":0},{"name":"address64.wast","passed":242,"failed":0},{"name":"align64.wast","passed":156,"failed":0},{"name":"binary-leb128.wast","passed":93,"failed":0},{"name":"binary.wast","passed":169,"failed":0},{"name":"endianness64.wast","passed":69,"failed":0},{"name":"float_memory64.wast","passed":90,"failed":0},{"name":"load64.wast","passed":97,"failed":0},{"name":"memory.wast","passed":79,"failed":0},{"name":"memory64.wast","passed":65,"failed":0},{"name":"memory_grow64.wast","passed":49,"failed":0},{"name":"memory_redundancy64.wast","passed":8,"failed":0},{"name":"memory_trap64.wast","passed":172,"failed":0},{"name":"simd_address.wast","passed":49,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-multi-memory.csv b/crates/tinywasm/tests/generated/wasm-multi-memory.csv
index 6b0a68a..9129240 100644
--- a/crates/tinywasm/tests/generated/wasm-multi-memory.csv
+++ b/crates/tinywasm/tests/generated/wasm-multi-memory.csv
@@ -1,2 +1,3 @@
 0.8.0,1872,0,[{"name":"address0.wast","passed":92,"failed":0},{"name":"address1.wast","passed":127,"failed":0},{"name":"align.wast","passed":160,"failed":0},{"name":"align0.wast","passed":5,"failed":0},{"name":"binary.wast","passed":126,"failed":0},{"name":"binary0.wast","passed":7,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"data0.wast","passed":7,"failed":0},{"name":"data1.wast","passed":14,"failed":0},{"name":"data_drop0.wast","passed":11,"failed":0},{"name":"exports0.wast","passed":8,"failed":0},{"name":"float_exprs0.wast","passed":14,"failed":0},{"name":"float_exprs1.wast","passed":3,"failed":0},{"name":"float_memory0.wast","passed":30,"failed":0},{"name":"imports.wast","passed":175,"failed":0},{"name":"imports0.wast","passed":8,"failed":0},{"name":"imports1.wast","passed":5,"failed":0},{"name":"imports2.wast","passed":20,"failed":0},{"name":"imports3.wast","passed":10,"failed":0},{"name":"imports4.wast","passed":16,"failed":0},{"name":"linking0.wast","passed":6,"failed":0},{"name":"linking1.wast","passed":14,"failed":0},{"name":"linking2.wast","passed":11,"failed":0},{"name":"linking3.wast","passed":14,"failed":0},{"name":"load.wast","passed":118,"failed":0},{"name":"load0.wast","passed":3,"failed":0},{"name":"load1.wast","passed":18,"failed":0},{"name":"load2.wast","passed":38,"failed":0},{"name":"memory-multi.wast","passed":6,"failed":0},{"name":"memory.wast","passed":86,"failed":0},{"name":"memory_copy0.wast","passed":29,"failed":0},{"name":"memory_copy1.wast","passed":14,"failed":0},{"name":"memory_fill0.wast","passed":16,"failed":0},{"name":"memory_grow.wast","passed":157,"failed":0},{"name":"memory_init0.wast","passed":13,"failed":0},{"name":"memory_size.wast","passed":49,"failed":0},{"name":"memory_size0.wast","passed":8,"failed":0},{"name":"memory_size1.wast","passed":15,"failed":0},{"name":"memory_size2.wast","passed":21,"failed":0},{"name":"memory_size3.wast","passed":2,"failed":0},{"name":"memory_trap0.wast","passed":14,"failed":0},{"name":"memory_trap1.wast","passed":168,"failed":0},{"name":"multi-memory/simd_memory-multi.wast (skipped)","passed":0,"failed":0},{"name":"start0.wast","passed":9,"failed":0},{"name":"store.wast","passed":111,"failed":0},{"name":"store0.wast","passed":5,"failed":0},{"name":"store1.wast","passed":13,"failed":0},{"name":"traps0.wast","passed":15,"failed":0}]
 0.9.0,912,0,[{"name":"address0.wast","passed":92,"failed":0},{"name":"address1.wast","passed":127,"failed":0},{"name":"align0.wast","passed":5,"failed":0},{"name":"binary0.wast","passed":7,"failed":0},{"name":"data0.wast","passed":7,"failed":0},{"name":"data1.wast","passed":14,"failed":0},{"name":"data_drop0.wast","passed":11,"failed":0},{"name":"exports0.wast","passed":8,"failed":0},{"name":"float_exprs0.wast","passed":14,"failed":0},{"name":"float_exprs1.wast","passed":3,"failed":0},{"name":"float_memory0.wast","passed":30,"failed":0},{"name":"imports0.wast","passed":8,"failed":0},{"name":"imports1.wast","passed":5,"failed":0},{"name":"imports2.wast","passed":20,"failed":0},{"name":"imports3.wast","passed":10,"failed":0},{"name":"imports4.wast","passed":16,"failed":0},{"name":"linking0.wast","passed":6,"failed":0},{"name":"linking1.wast","passed":14,"failed":0},{"name":"linking2.wast","passed":11,"failed":0},{"name":"linking3.wast","passed":14,"failed":0},{"name":"load0.wast","passed":3,"failed":0},{"name":"load1.wast","passed":18,"failed":0},{"name":"load2.wast","passed":38,"failed":0},{"name":"memory-multi.wast","passed":6,"failed":0},{"name":"memory_copy0.wast","passed":29,"failed":0},{"name":"memory_copy1.wast","passed":14,"failed":0},{"name":"memory_fill0.wast","passed":16,"failed":0},{"name":"memory_grow.wast","passed":51,"failed":0},{"name":"memory_init0.wast","passed":13,"failed":0},{"name":"memory_size0.wast","passed":8,"failed":0},{"name":"memory_size1.wast","passed":15,"failed":0},{"name":"memory_size2.wast","passed":21,"failed":0},{"name":"memory_size3.wast","passed":2,"failed":0},{"name":"memory_size_import.wast","passed":7,"failed":0},{"name":"memory_trap0.wast","passed":14,"failed":0},{"name":"memory_trap1.wast","passed":168,"failed":0},{"name":"start0.wast","passed":9,"failed":0},{"name":"store0.wast","passed":5,"failed":0},{"name":"store1.wast","passed":13,"failed":0},{"name":"store2.wast","passed":25,"failed":0},{"name":"traps0.wast","passed":15,"failed":0}]
+0.9.1,912,0,[{"name":"address0.wast","passed":92,"failed":0},{"name":"address1.wast","passed":127,"failed":0},{"name":"align0.wast","passed":5,"failed":0},{"name":"binary0.wast","passed":7,"failed":0},{"name":"data0.wast","passed":7,"failed":0},{"name":"data1.wast","passed":14,"failed":0},{"name":"data_drop0.wast","passed":11,"failed":0},{"name":"exports0.wast","passed":8,"failed":0},{"name":"float_exprs0.wast","passed":14,"failed":0},{"name":"float_exprs1.wast","passed":3,"failed":0},{"name":"float_memory0.wast","passed":30,"failed":0},{"name":"imports0.wast","passed":8,"failed":0},{"name":"imports1.wast","passed":5,"failed":0},{"name":"imports2.wast","passed":20,"failed":0},{"name":"imports3.wast","passed":10,"failed":0},{"name":"imports4.wast","passed":16,"failed":0},{"name":"linking0.wast","passed":6,"failed":0},{"name":"linking1.wast","passed":14,"failed":0},{"name":"linking2.wast","passed":11,"failed":0},{"name":"linking3.wast","passed":14,"failed":0},{"name":"load0.wast","passed":3,"failed":0},{"name":"load1.wast","passed":18,"failed":0},{"name":"load2.wast","passed":38,"failed":0},{"name":"memory-multi.wast","passed":6,"failed":0},{"name":"memory_copy0.wast","passed":29,"failed":0},{"name":"memory_copy1.wast","passed":14,"failed":0},{"name":"memory_fill0.wast","passed":16,"failed":0},{"name":"memory_grow.wast","passed":51,"failed":0},{"name":"memory_init0.wast","passed":13,"failed":0},{"name":"memory_size0.wast","passed":8,"failed":0},{"name":"memory_size1.wast","passed":15,"failed":0},{"name":"memory_size2.wast","passed":21,"failed":0},{"name":"memory_size3.wast","passed":2,"failed":0},{"name":"memory_size_import.wast","passed":7,"failed":0},{"name":"memory_trap0.wast","passed":14,"failed":0},{"name":"memory_trap1.wast","passed":168,"failed":0},{"name":"start0.wast","passed":9,"failed":0},{"name":"store0.wast","passed":5,"failed":0},{"name":"store1.wast","passed":13,"failed":0},{"name":"store2.wast","passed":25,"failed":0},{"name":"traps0.wast","passed":15,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-nontrapping-float-to-int-conversions.csv b/crates/tinywasm/tests/generated/wasm-nontrapping-float-to-int-conversions.csv
index 3420339..5f8c1d9 100644
--- a/crates/tinywasm/tests/generated/wasm-nontrapping-float-to-int-conversions.csv
+++ b/crates/tinywasm/tests/generated/wasm-nontrapping-float-to-int-conversions.csv
@@ -1 +1,2 @@
 0.9.0,615,0,[{"name":"conversions.wast","passed":615,"failed":0}]
+0.9.1,615,0,[{"name":"conversions.wast","passed":615,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-reference-types.csv b/crates/tinywasm/tests/generated/wasm-reference-types.csv
index 5e2cf89..75056b3 100644
--- a/crates/tinywasm/tests/generated/wasm-reference-types.csv
+++ b/crates/tinywasm/tests/generated/wasm-reference-types.csv
@@ -1 +1,2 @@
 0.9.0,9124,0,[{"name":"binary-leb128.wast","passed":77,"failed":0},{"name":"binary.wast","passed":134,"failed":0},{"name":"br_table.wast","passed":172,"failed":0},{"name":"bulk.wast","passed":117,"failed":0},{"name":"call_indirect.wast","passed":169,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":45,"failed":0},{"name":"elem.wast","passed":60,"failed":0},{"name":"exports.wast","passed":84,"failed":0},{"name":"global.wast","passed":86,"failed":0},{"name":"imports.wast","passed":158,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":96,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"ref_func.wast","passed":17,"failed":0},{"name":"ref_is_null.wast","passed":16,"failed":0},{"name":"ref_null.wast","passed":3,"failed":0},{"name":"select.wast","passed":141,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1728,"failed":0},{"name":"table_fill.wast","passed":45,"failed":0},{"name":"table_get.wast","passed":16,"failed":0},{"name":"table_grow.wast","passed":50,"failed":0},{"name":"table_init.wast","passed":780,"failed":0},{"name":"table_set.wast","passed":26,"failed":0},{"name":"table_size.wast","passed":39,"failed":0},{"name":"unreached-invalid.wast","passed":111,"failed":0}]
+0.9.1,9124,0,[{"name":"binary-leb128.wast","passed":77,"failed":0},{"name":"binary.wast","passed":134,"failed":0},{"name":"br_table.wast","passed":172,"failed":0},{"name":"bulk.wast","passed":117,"failed":0},{"name":"call_indirect.wast","passed":169,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":45,"failed":0},{"name":"elem.wast","passed":60,"failed":0},{"name":"exports.wast","passed":84,"failed":0},{"name":"global.wast","passed":86,"failed":0},{"name":"imports.wast","passed":158,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":96,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"ref_func.wast","passed":17,"failed":0},{"name":"ref_is_null.wast","passed":16,"failed":0},{"name":"ref_null.wast","passed":3,"failed":0},{"name":"select.wast","passed":141,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1728,"failed":0},{"name":"table_fill.wast","passed":45,"failed":0},{"name":"table_get.wast","passed":16,"failed":0},{"name":"table_grow.wast","passed":50,"failed":0},{"name":"table_init.wast","passed":780,"failed":0},{"name":"table_set.wast","passed":26,"failed":0},{"name":"table_size.wast","passed":39,"failed":0},{"name":"unreached-invalid.wast","passed":111,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-relaxed-simd.csv b/crates/tinywasm/tests/generated/wasm-relaxed-simd.csv
index e407b5c..a8a6158 100644
--- a/crates/tinywasm/tests/generated/wasm-relaxed-simd.csv
+++ b/crates/tinywasm/tests/generated/wasm-relaxed-simd.csv
@@ -1 +1,2 @@
 0.9.0,77,0,[{"name":"i16x8_relaxed_q15mulr_s.wast","passed":3,"failed":0},{"name":"i32x4_relaxed_trunc.wast","passed":1,"failed":0},{"name":"i8x16_relaxed_swizzle.wast","passed":6,"failed":0},{"name":"relaxed_dot_product.wast","passed":11,"failed":0},{"name":"relaxed_laneselect.wast","passed":12,"failed":0},{"name":"relaxed_madd_nmadd.wast","passed":19,"failed":0},{"name":"relaxed_min_max.wast","passed":25,"failed":0}]
+0.9.1,77,0,[{"name":"i16x8_relaxed_q15mulr_s.wast","passed":3,"failed":0},{"name":"i32x4_relaxed_trunc.wast","passed":1,"failed":0},{"name":"i8x16_relaxed_swizzle.wast","passed":6,"failed":0},{"name":"relaxed_dot_product.wast","passed":11,"failed":0},{"name":"relaxed_laneselect.wast","passed":12,"failed":0},{"name":"relaxed_madd_nmadd.wast","passed":19,"failed":0},{"name":"relaxed_min_max.wast","passed":25,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-sign-extension-ops.csv b/crates/tinywasm/tests/generated/wasm-sign-extension-ops.csv
index 0f11185..59144c8 100644
--- a/crates/tinywasm/tests/generated/wasm-sign-extension-ops.csv
+++ b/crates/tinywasm/tests/generated/wasm-sign-extension-ops.csv
@@ -1 +1,2 @@
 0.9.0,872,0,[{"name":"i32.wast","passed":458,"failed":0},{"name":"i64.wast","passed":414,"failed":0}]
+0.9.1,872,0,[{"name":"i32.wast","passed":458,"failed":0},{"name":"i64.wast","passed":414,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-simd.csv b/crates/tinywasm/tests/generated/wasm-simd.csv
index a38c8ef..d53e9ec 100644
--- a/crates/tinywasm/tests/generated/wasm-simd.csv
+++ b/crates/tinywasm/tests/generated/wasm-simd.csv
@@ -1,2 +1,3 @@
 0.8.0,1300,24679,[{"name":"simd_address.wast","passed":4,"failed":45},{"name":"simd_align.wast","passed":46,"failed":54},{"name":"simd_bit_shift.wast","passed":39,"failed":213},{"name":"simd_bitwise.wast","passed":28,"failed":141},{"name":"simd_boolean.wast","passed":16,"failed":261},{"name":"simd_const.wast","passed":301,"failed":456},{"name":"simd_conversions.wast","passed":48,"failed":234},{"name":"simd_f32x4.wast","passed":16,"failed":774},{"name":"simd_f32x4_arith.wast","passed":16,"failed":1806},{"name":"simd_f32x4_cmp.wast","passed":24,"failed":2583},{"name":"simd_f32x4_pmin_pmax.wast","passed":14,"failed":3873},{"name":"simd_f32x4_rounding.wast","passed":24,"failed":177},{"name":"simd_f64x2.wast","passed":8,"failed":795},{"name":"simd_f64x2_arith.wast","passed":16,"failed":1809},{"name":"simd_f64x2_cmp.wast","passed":24,"failed":2661},{"name":"simd_f64x2_pmin_pmax.wast","passed":14,"failed":3873},{"name":"simd_f64x2_rounding.wast","passed":24,"failed":177},{"name":"simd_i16x8_arith.wast","passed":11,"failed":183},{"name":"simd_i16x8_arith2.wast","passed":19,"failed":153},{"name":"simd_i16x8_cmp.wast","passed":30,"failed":435},{"name":"simd_i16x8_extadd_pairwise_i8x16.wast","passed":4,"failed":17},{"name":"simd_i16x8_extmul_i8x16.wast","passed":12,"failed":105},{"name":"simd_i16x8_q15mulr_sat_s.wast","passed":3,"failed":27},{"name":"simd_i16x8_sat_arith.wast","passed":16,"failed":206},{"name":"simd_i32x4_arith.wast","passed":11,"failed":183},{"name":"simd_i32x4_arith2.wast","passed":26,"failed":123},{"name":"simd_i32x4_cmp.wast","passed":40,"failed":435},{"name":"simd_i32x4_dot_i16x8.wast","passed":3,"failed":27},{"name":"simd_i32x4_extadd_pairwise_i16x8.wast","passed":4,"failed":17},{"name":"simd_i32x4_extmul_i16x8.wast","passed":12,"failed":105},{"name":"simd_i32x4_trunc_sat_f32x4.wast","passed":4,"failed":103},{"name":"simd_i32x4_trunc_sat_f64x2.wast","passed":4,"failed":103},{"name":"simd_i64x2_arith.wast","passed":11,"failed":189},{"name":"simd_i64x2_arith2.wast","passed":2,"failed":23},{"name":"simd_i64x2_cmp.wast","passed":10,"failed":103},{"name":"simd_i64x2_extmul_i32x4.wast","passed":12,"failed":105},{"name":"simd_i8x16_arith.wast","passed":8,"failed":123},{"name":"simd_i8x16_arith2.wast","passed":25,"failed":186},{"name":"simd_i8x16_cmp.wast","passed":30,"failed":415},{"name":"simd_i8x16_sat_arith.wast","passed":24,"failed":190},{"name":"simd_int_to_int_extend.wast","passed":24,"failed":229},{"name":"simd_lane.wast","passed":189,"failed":286},{"name":"simd_linking.wast","passed":0,"failed":3},{"name":"simd_load.wast","passed":8,"failed":31},{"name":"simd_load16_lane.wast","passed":3,"failed":33},{"name":"simd_load32_lane.wast","passed":3,"failed":21},{"name":"simd_load64_lane.wast","passed":3,"failed":13},{"name":"simd_load8_lane.wast","passed":3,"failed":49},{"name":"simd_load_extend.wast","passed":18,"failed":86},{"name":"simd_load_splat.wast","passed":12,"failed":114},{"name":"simd_load_zero.wast","passed":10,"failed":29},{"name":"simd_splat.wast","passed":23,"failed":162},{"name":"simd_store.wast","passed":9,"failed":19},{"name":"simd_store16_lane.wast","passed":3,"failed":33},{"name":"simd_store32_lane.wast","passed":3,"failed":21},{"name":"simd_store64_lane.wast","passed":3,"failed":13},{"name":"simd_store8_lane.wast","passed":3,"failed":49}]
 0.9.0,25990,0,[{"name":"simd_address.wast","passed":49,"failed":0},{"name":"simd_align.wast","passed":100,"failed":0},{"name":"simd_bit_shift.wast","passed":252,"failed":0},{"name":"simd_bitwise.wast","passed":169,"failed":0},{"name":"simd_boolean.wast","passed":277,"failed":0},{"name":"simd_const.wast","passed":758,"failed":0},{"name":"simd_conversions.wast","passed":282,"failed":0},{"name":"simd_f32x4.wast","passed":790,"failed":0},{"name":"simd_f32x4_arith.wast","passed":1822,"failed":0},{"name":"simd_f32x4_cmp.wast","passed":2607,"failed":0},{"name":"simd_f32x4_pmin_pmax.wast","passed":3887,"failed":0},{"name":"simd_f32x4_rounding.wast","passed":201,"failed":0},{"name":"simd_f64x2.wast","passed":803,"failed":0},{"name":"simd_f64x2_arith.wast","passed":1825,"failed":0},{"name":"simd_f64x2_cmp.wast","passed":2685,"failed":0},{"name":"simd_f64x2_pmin_pmax.wast","passed":3887,"failed":0},{"name":"simd_f64x2_rounding.wast","passed":201,"failed":0},{"name":"simd_i16x8_arith.wast","passed":194,"failed":0},{"name":"simd_i16x8_arith2.wast","passed":172,"failed":0},{"name":"simd_i16x8_cmp.wast","passed":465,"failed":0},{"name":"simd_i16x8_extadd_pairwise_i8x16.wast","passed":21,"failed":0},{"name":"simd_i16x8_extmul_i8x16.wast","passed":117,"failed":0},{"name":"simd_i16x8_q15mulr_sat_s.wast","passed":30,"failed":0},{"name":"simd_i16x8_sat_arith.wast","passed":222,"failed":0},{"name":"simd_i32x4_arith.wast","passed":194,"failed":0},{"name":"simd_i32x4_arith2.wast","passed":149,"failed":0},{"name":"simd_i32x4_cmp.wast","passed":475,"failed":0},{"name":"simd_i32x4_dot_i16x8.wast","passed":32,"failed":0},{"name":"simd_i32x4_extadd_pairwise_i16x8.wast","passed":21,"failed":0},{"name":"simd_i32x4_extmul_i16x8.wast","passed":117,"failed":0},{"name":"simd_i32x4_trunc_sat_f32x4.wast","passed":107,"failed":0},{"name":"simd_i32x4_trunc_sat_f64x2.wast","passed":107,"failed":0},{"name":"simd_i64x2_arith.wast","passed":200,"failed":0},{"name":"simd_i64x2_arith2.wast","passed":25,"failed":0},{"name":"simd_i64x2_cmp.wast","passed":113,"failed":0},{"name":"simd_i64x2_extmul_i32x4.wast","passed":117,"failed":0},{"name":"simd_i8x16_arith.wast","passed":131,"failed":0},{"name":"simd_i8x16_arith2.wast","passed":211,"failed":0},{"name":"simd_i8x16_cmp.wast","passed":445,"failed":0},{"name":"simd_i8x16_sat_arith.wast","passed":214,"failed":0},{"name":"simd_int_to_int_extend.wast","passed":253,"failed":0},{"name":"simd_lane.wast","passed":475,"failed":0},{"name":"simd_linking.wast","passed":3,"failed":0},{"name":"simd_load.wast","passed":39,"failed":0},{"name":"simd_load16_lane.wast","passed":36,"failed":0},{"name":"simd_load32_lane.wast","passed":24,"failed":0},{"name":"simd_load64_lane.wast","passed":16,"failed":0},{"name":"simd_load8_lane.wast","passed":52,"failed":0},{"name":"simd_load_extend.wast","passed":104,"failed":0},{"name":"simd_load_splat.wast","passed":126,"failed":0},{"name":"simd_load_zero.wast","passed":39,"failed":0},{"name":"simd_memory-multi.wast","passed":1,"failed":0},{"name":"simd_select.wast","passed":7,"failed":0},{"name":"simd_splat.wast","passed":185,"failed":0},{"name":"simd_store.wast","passed":28,"failed":0},{"name":"simd_store16_lane.wast","passed":36,"failed":0},{"name":"simd_store32_lane.wast","passed":24,"failed":0},{"name":"simd_store64_lane.wast","passed":16,"failed":0},{"name":"simd_store8_lane.wast","passed":52,"failed":0}]
+0.9.1,25990,0,[{"name":"simd_address.wast","passed":49,"failed":0},{"name":"simd_align.wast","passed":100,"failed":0},{"name":"simd_bit_shift.wast","passed":252,"failed":0},{"name":"simd_bitwise.wast","passed":169,"failed":0},{"name":"simd_boolean.wast","passed":277,"failed":0},{"name":"simd_const.wast","passed":758,"failed":0},{"name":"simd_conversions.wast","passed":282,"failed":0},{"name":"simd_f32x4.wast","passed":790,"failed":0},{"name":"simd_f32x4_arith.wast","passed":1822,"failed":0},{"name":"simd_f32x4_cmp.wast","passed":2607,"failed":0},{"name":"simd_f32x4_pmin_pmax.wast","passed":3887,"failed":0},{"name":"simd_f32x4_rounding.wast","passed":201,"failed":0},{"name":"simd_f64x2.wast","passed":803,"failed":0},{"name":"simd_f64x2_arith.wast","passed":1825,"failed":0},{"name":"simd_f64x2_cmp.wast","passed":2685,"failed":0},{"name":"simd_f64x2_pmin_pmax.wast","passed":3887,"failed":0},{"name":"simd_f64x2_rounding.wast","passed":201,"failed":0},{"name":"simd_i16x8_arith.wast","passed":194,"failed":0},{"name":"simd_i16x8_arith2.wast","passed":172,"failed":0},{"name":"simd_i16x8_cmp.wast","passed":465,"failed":0},{"name":"simd_i16x8_extadd_pairwise_i8x16.wast","passed":21,"failed":0},{"name":"simd_i16x8_extmul_i8x16.wast","passed":117,"failed":0},{"name":"simd_i16x8_q15mulr_sat_s.wast","passed":30,"failed":0},{"name":"simd_i16x8_sat_arith.wast","passed":222,"failed":0},{"name":"simd_i32x4_arith.wast","passed":194,"failed":0},{"name":"simd_i32x4_arith2.wast","passed":149,"failed":0},{"name":"simd_i32x4_cmp.wast","passed":475,"failed":0},{"name":"simd_i32x4_dot_i16x8.wast","passed":32,"failed":0},{"name":"simd_i32x4_extadd_pairwise_i16x8.wast","passed":21,"failed":0},{"name":"simd_i32x4_extmul_i16x8.wast","passed":117,"failed":0},{"name":"simd_i32x4_trunc_sat_f32x4.wast","passed":107,"failed":0},{"name":"simd_i32x4_trunc_sat_f64x2.wast","passed":107,"failed":0},{"name":"simd_i64x2_arith.wast","passed":200,"failed":0},{"name":"simd_i64x2_arith2.wast","passed":25,"failed":0},{"name":"simd_i64x2_cmp.wast","passed":113,"failed":0},{"name":"simd_i64x2_extmul_i32x4.wast","passed":117,"failed":0},{"name":"simd_i8x16_arith.wast","passed":131,"failed":0},{"name":"simd_i8x16_arith2.wast","passed":211,"failed":0},{"name":"simd_i8x16_cmp.wast","passed":445,"failed":0},{"name":"simd_i8x16_sat_arith.wast","passed":214,"failed":0},{"name":"simd_int_to_int_extend.wast","passed":253,"failed":0},{"name":"simd_lane.wast","passed":475,"failed":0},{"name":"simd_linking.wast","passed":3,"failed":0},{"name":"simd_load.wast","passed":39,"failed":0},{"name":"simd_load16_lane.wast","passed":36,"failed":0},{"name":"simd_load32_lane.wast","passed":24,"failed":0},{"name":"simd_load64_lane.wast","passed":16,"failed":0},{"name":"simd_load8_lane.wast","passed":52,"failed":0},{"name":"simd_load_extend.wast","passed":104,"failed":0},{"name":"simd_load_splat.wast","passed":126,"failed":0},{"name":"simd_load_zero.wast","passed":39,"failed":0},{"name":"simd_memory-multi.wast","passed":1,"failed":0},{"name":"simd_select.wast","passed":7,"failed":0},{"name":"simd_splat.wast","passed":185,"failed":0},{"name":"simd_store.wast","passed":28,"failed":0},{"name":"simd_store16_lane.wast","passed":36,"failed":0},{"name":"simd_store32_lane.wast","passed":24,"failed":0},{"name":"simd_store64_lane.wast","passed":16,"failed":0},{"name":"simd_store8_lane.wast","passed":52,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-tail-call.csv b/crates/tinywasm/tests/generated/wasm-tail-call.csv
index 9721bd2..de5c618 100644
--- a/crates/tinywasm/tests/generated/wasm-tail-call.csv
+++ b/crates/tinywasm/tests/generated/wasm-tail-call.csv
@@ -1 +1,2 @@
 0.9.0,119,0,[{"name":"return_call.wast","passed":44,"failed":0},{"name":"return_call_indirect.wast","passed":75,"failed":0}]
+0.9.1,119,0,[{"name":"return_call.wast","passed":44,"failed":0},{"name":"return_call_indirect.wast","passed":75,"failed":0}]
diff --git a/crates/tinywasm/tests/generated/wasm-wide-arithmetic.csv b/crates/tinywasm/tests/generated/wasm-wide-arithmetic.csv
index ae302ad..95d9360 100644
--- a/crates/tinywasm/tests/generated/wasm-wide-arithmetic.csv
+++ b/crates/tinywasm/tests/generated/wasm-wide-arithmetic.csv
@@ -1 +1,2 @@
 0.9.0,109,0,[{"name":"wide-arithmetic.wast","passed":109,"failed":0}]
+0.9.1,109,0,[{"name":"wide-arithmetic.wast","passed":109,"failed":0}]
author	Henry <mail@henrygressmann.de>	2026-07-08 16:13:22 +0200
committer	Henry <mail@henrygressmann.de>	2026-07-08 16:13:22 +0200
commit	6e28708ca6b78419117d27bbae916ac44b90d306 (patch)
tree	08e41c28caf57cb4e8c6e0f09daad443b2c9444b
parent	71e8948fbde0a6fd61195501fd4a89609c402bbb (diff)