copy optimized blitSprite impl to grabSprite, add simple docs

examples/curlywas/sprites.cwa

@@ -0,0 +1,21 @@
+include "../include/microw8-api.cwa"
+
+const SPRITE = 0x20000;
+
+export fn upd() {
+	cls(0);
+	let t = time();
+	let i: i32;
+	loop spriteLoop {
+		let inline x = sin(t * -1.3 + i as f32 / 8_f) * 180_f + 160_f;
+		let inline y = sin(t * 1.7 + i as f32 / 9_f) * 140_f + 120_f;
+		blitSprite(SPRITE, 16, x as i32, y as i32, 0x100);
+		branch_if (i +:= 1) < 200: spriteLoop;
+	}
+}
+
+start fn start() {
+	printChar('OO');
+	circle(8_f, 8_f, 6_f, 75);
+	grabSprite(SPRITE, 16, 0, 0, 0);
+}

examples/include/microw8-api.cwa

@@ -30,11 +30,13 @@ import "env.printInt" fn printInt(i32);
 import "env.setTextColor" fn setTextColor(i32);
 import "env.setBackgroundColor" fn setBackgroundColor(i32);
 import "env.setCursorPosition" fn setCursorPosition(i32, i32);
-import "env.rectangle_outline" fn rectangle_outline(f32, f32, f32, f32, i32);
-import "env.circle_outline" fn circle_outline(f32, f32, f32, i32);
+import "env.rectangleOutline" fn rectangleOutline(f32, f32, f32, f32, i32);
+import "env.circleOutline" fn circleOutline(f32, f32, f32, i32);
 import "env.exp" fn exp(f32) -> f32;
 import "env.playNote" fn playNote(i32, i32);
 import "env.sndGes" fn sndGes(i32) -> f32;
+import "env.blitSprite" fn blitSprite(i32, i32, i32, i32, i32);
+import "env.grabSprite" fn grabSprite(i32, i32, i32, i32, i32);
 
 const TIME_MS = 0x40;
 const GAMEPAD = 0x44;

examples/include/microw8-api.wat

@@ -30,11 +30,13 @@
 (import "env" "setTextColor" (func $setTextColor (param i32)))
 (import "env" "setBackgroundColor" (func $setBackgroundColor (param i32)))
 (import "env" "setCursorPosition" (func $setCursorPosition (param i32) (param i32)))
-(import "env" "rectangle_outline" (func $rectangle_outline (param f32) (param f32) (param f32) (param f32) (param i32)))
-(import "env" "circle_outline" (func $circle_outline (param f32) (param f32) (param f32) (param i32)))
+(import "env" "rectangleOutline" (func $rectangleOutline (param f32) (param f32) (param f32) (param f32) (param i32)))
+(import "env" "circleOutline" (func $circleOutline (param f32) (param f32) (param f32) (param i32)))
 (import "env" "exp" (func $exp (param f32) (result f32)))
 (import "env" "playNote" (func $playNote (param i32) (param i32)))
 (import "env" "sndGes" (func $sndGes (param i32) (result f32)))
+(import "env" "blitSprite" (func $blitSprite (param i32) (param i32) (param i32) (param i32) (param i32)))
+(import "env" "grabSprite" (func $grabSprite (param i32) (param i32) (param i32) (param i32) (param i32)))
 
 ;; to use defines, include this file with a preprocessor
 ;; like gpp (https://logological.org/gpp).

platform/src/platform.cwa

@@ -171,7 +171,7 @@ export fn rectangle(x: f32, y: f32, w: f32, h: f32, col: i32) {
     }
 }
 
-export fn rectangle_outline(x: f32, y: f32, w: f32, h: f32, col: i32) {
+export fn rectangleOutline(x: f32, y: f32, w: f32, h: f32, col: i32) {
     let xl = nearest(x) as i32;
     let xr = nearest(x + w) as i32;
     let yt = nearest(y) as i32;
@@ -212,7 +212,7 @@ export fn circle(cx: f32, cy: f32, radius: f32, col: i32) {
     }
 }
 
-export fn circle_outline(cx: f32, cy: f32, radius: f32, col: i32) {
+export fn circleOutline(cx: f32, cy: f32, radius: f32, col: i32) {
     let prev_w: f32;
     let y = clamp(nearest(cy - radius) as i32, -1, 241);
     let maxY = clamp(nearest(cy + radius) as i32, -1, 241);
@@ -352,6 +352,92 @@ export fn line(x1: f32, y1: f32, x2: f32, y2: f32, col: i32) {
     setPixel(i32.trunc_sat_f32_s(x1 + f * dx), i32.trunc_sat_f32_s(y1 + f * dy), col);
 }
 
+export fn blitSprite(sprite: i32, size: i32, x: i32, y: i32, control: i32) {
+    let lazy width = size & 65535;
+    let lazy height = select(size >> 16, size >> 16, width);
+
+    let lazy x0 = select(x < 0, -x, 0);
+    let lazy x1 = select(x + width > 320, 320 - x, width);
+    let lazy y0 = select(y < 0, -y, 0);
+    let lazy y1 = select(y + height > 240, 240 - y, height);
+
+    let lazy numRows = y1 - y0;
+    let lazy numCols = x1 - x0;
+    if numRows <= 0 | numCols <= 0 {
+        return;
+    }
+
+    let trans = (control & 511) - 256;
+    let lazy flip_x = 1 - ((control >> 8) & 2);
+    let lazy flip_y = 1 - ((control >> 9) & 2);
+    if flip_x < 0 {
+        sprite += width - 1;
+    }
+    if flip_y < 0 {
+        sprite += (height - 1) * width;
+    }
+
+    let spriteRow = sprite + x0 * flip_x + y0 * flip_y * width;
+    let screenRow = x + x0 + (y + y0) * 320;
+
+    loop yloop {
+        let lx = 0;
+        loop xloop {
+            let lazy col = (spriteRow + lx * flip_x)?0;
+            if col != trans {
+                (screenRow + lx)?120 = col;
+            }
+            branch_if (lx +:= 1) < numCols: xloop;
+        }
+        spriteRow += width * flip_y;
+        screenRow += 320;
+        branch_if numRows -:= 1: yloop;
+    }
+}
+
+export fn grabSprite(sprite: i32, size: i32, x: i32, y: i32, control: i32) {
+    let lazy width = size & 65535;
+    let lazy height = select(size >> 16, size >> 16, width);
+
+    let lazy x0 = select(x < 0, -x, 0);
+    let lazy x1 = select(x + width > 320, 320 - x, width);
+    let lazy y0 = select(y < 0, -y, 0);
+    let lazy y1 = select(y + height > 240, 240 - y, height);
+
+    let lazy numRows = y1 - y0;
+    let lazy numCols = x1 - x0;
+    if numRows <= 0 | numCols <= 0 {
+        return;
+    }
+
+    let trans = (control & 511) - 256;
+    let lazy flip_x = 1 - ((control >> 8) & 2);
+    let lazy flip_y = 1 - ((control >> 9) & 2);
+    if flip_x < 0 {
+        sprite += width - 1;
+    }
+    if flip_y < 0 {
+        sprite += (height - 1) * width;
+    }
+
+    let spriteRow = sprite + x0 * flip_x + y0 * flip_y * width;
+    let screenRow = x + x0 + (y + y0) * 320;
+
+    loop yloop {
+        let lx = 0;
+        loop xloop {
+            let lazy col = (screenRow + lx)?120;
+            if col != trans {
+                (spriteRow + lx * flip_x)?0 = col;
+            }
+            branch_if (lx +:= 1) < numCols: xloop;
+        }
+        spriteRow += width * flip_y;
+        screenRow += 320;
+        branch_if numRows -:= 1: yloop;
+    }
+}
+
 //////////
 // TEXT //
 //////////

site/content/docs.md

@@ -146,13 +146,13 @@ Fills the circle at `cx, cy` and with `radius` with the given color index.
 
 (Sets all pixels where the pixel center lies inside the circle.)
 
-### fn rectangle_outline(x: f32, y: f32, w: f32, h: f32, color: i32)
+### fn rectangleOutline(x: f32, y: f32, w: f32, h: f32, color: i32)
 
 Draws a one pixel outline on the inside of the given rectangle.
 
 (Draws the outermost pixels that are still inside the rectangle area.)
 
-### fn circle_outline(cx: f32, cy: f32, radius: f32, color: i32)
+### fn circleOutline(cx: f32, cy: f32, radius: f32, color: i32)
 
 Draws a one pixel outline on the inside of the given circle.
 
@@ -162,6 +162,21 @@ Draws a one pixel outline on the inside of the given circle.
 
 Draws a line from `x1,y1` to `x2,y2` in the given color index.
 
+### fn blitSprite(spriteData: i32, size: i32, x: i32, y: i32, control: i32)
+
+Copies the pixel data at `spriteData` onto the screen at `x`, `y`. The size of the sprite is passed as `width | (height << 16)`.
+If the height is given as 0, the sprite is is treated as square (width x width).
+
+The control parameter controls masking and flipping of the sprite:
+* bits 0-7: color mask index
+* bit 8: switch on masked blit (pixel with color mask index are treated as transparent)
+* bit 9: flip sprite x
+* bit 10: flip sprite y
+
+### fn grabSprite(spriteData: i32, size: i32, x: i32, y: i32, control: i32)
+
+Copies the pixel data on the screen at `x`, `y` to `spriteData`. Parameters are exactly the same as `blitSprite`.
+
 ## Input
 
 MicroW8 provides input from a gamepad with one D-Pad and 4 buttons, or a keyboard emulation thereof.

uw8-tool/src/base_module.rs

@@ -152,14 +152,14 @@ impl BaseModule {
         add_function(
             &mut functions,
             &type_map,
-            "rectangle_outline",
+            "rectangleOutline",
             &[F32, F32, F32, F32, I32],
             None,
         );
         add_function(
             &mut functions,
             &type_map,
-            "circle_outline",
+            "circleOutline",
             &[F32, F32, F32, I32],
             None,
         );
@@ -169,6 +169,21 @@ impl BaseModule {
         add_function(&mut functions, &type_map, "playNote", &[I32, I32], None);
         add_function(&mut functions, &type_map, "sndGes", &[I32], Some(F32));
 
+        add_function(
+            &mut functions,
+            &type_map,
+            "blitSprite",
+            &[I32, I32, I32, I32, I32],
+            None,
+        );
+        add_function(
+            &mut functions,
+            &type_map,
+            "grabSprite",
+            &[I32, I32, I32, I32, I32],
+            None,
+        );
+
         for i in functions.len()..64 {
             add_function(
                 &mut functions,

uw8-tool/src/pack.rs

@@ -143,7 +143,6 @@ fn to_val_type(type_: &wasmparser::ValType) -> Result<ValType> {
         I64 => ValType::I64,
         F32 => ValType::F32,
         F64 => ValType::F64,
-        V128 => ValType::V128,
         _ => bail!("Type {:?} isn't a value type", type_),
     })
 }
@@ -968,244 +967,6 @@ fn remap_function(
             De::I64TruncSatF64U => En::I64TruncSatF64U,
             De::MemoryCopy { src_mem, dst_mem } => En::MemoryCopy { src_mem, dst_mem },
             De::MemoryFill { mem } => En::MemoryFill(mem),
-
-            De::V128Const { value } => En::V128Const(value.i128()),
-            De::V128Load { memarg } => En::V128Load(mem(memarg)),
-            De::V128Store { memarg } => En::V128Store(mem(memarg)),
-            De::V128Load8x8S { memarg } => En::V128Load8x8S(mem(memarg)),
-            De::V128Load8x8U { memarg } => En::V128Load8x8U(mem(memarg)),
-            De::V128Load16x4S { memarg } => En::V128Load16x4S(mem(memarg)),
-            De::V128Load16x4U { memarg } => En::V128Load16x4U(mem(memarg)),
-            De::V128Load32x2S { memarg } => En::V128Load32x2S(mem(memarg)),
-            De::V128Load32x2U { memarg } => En::V128Load32x2U(mem(memarg)),
-            De::V128Load8Splat { memarg } => En::V128Load8Splat(mem(memarg)),
-            De::V128Load16Splat { memarg } => En::V128Load16Splat(mem(memarg)),
-            De::V128Load32Splat { memarg } => En::V128Load32Splat(mem(memarg)),
-            De::V128Load64Splat { memarg } => En::V128Load64Splat(mem(memarg)),
-            De::V128Load32Zero { memarg } => En::V128Load32Zero(mem(memarg)),
-            De::V128Load64Zero { memarg } => En::V128Load64Zero(mem(memarg)),
-
-            De::V128Load8Lane { memarg, lane } => En::V128Load8Lane { memarg: mem(memarg), lane },
-            De::V128Load16Lane { memarg, lane } => En::V128Load16Lane { memarg: mem(memarg), lane },
-            De::V128Load32Lane { memarg, lane } => En::V128Load32Lane { memarg: mem(memarg), lane },
-            De::V128Load64Lane { memarg, lane } => En::V128Load64Lane { memarg: mem(memarg), lane },
-            De::V128Store8Lane { memarg, lane } => En::V128Store8Lane { memarg: mem(memarg), lane },
-            De::V128Store16Lane { memarg, lane } => En::V128Store16Lane { memarg: mem(memarg), lane },
-            De::V128Store32Lane { memarg, lane } => En::V128Store32Lane { memarg: mem(memarg), lane },
-            De::V128Store64Lane { memarg, lane } => En::V128Store64Lane { memarg: mem(memarg), lane },
-
-            De::I8x16ExtractLaneS { lane } => En::I8x16ExtractLaneS(lane),
-            De::I8x16ExtractLaneU { lane } => En::I8x16ExtractLaneU(lane),
-            De::I8x16ReplaceLane { lane } => En::I8x16ReplaceLane(lane),
-            De::I16x8ExtractLaneS { lane } => En::I16x8ExtractLaneS(lane),
-            De::I16x8ExtractLaneU { lane } => En::I16x8ExtractLaneU(lane),
-            De::I16x8ReplaceLane { lane } => En::I16x8ReplaceLane(lane),
-            De::I32x4ExtractLane { lane } => En::I32x4ExtractLane(lane),
-            De::I32x4ReplaceLane { lane } => En::I32x4ReplaceLane(lane),
-            De::I64x2ExtractLane { lane } => En::I64x2ExtractLane(lane),
-            De::I64x2ReplaceLane { lane } => En::I64x2ReplaceLane(lane),
-            De::F32x4ExtractLane { lane } => En::F32x4ExtractLane(lane),
-            De::F32x4ReplaceLane { lane } => En::F32x4ReplaceLane(lane),
-            De::F64x2ExtractLane { lane } => En::F64x2ExtractLane(lane),
-            De::F64x2ReplaceLane { lane } => En::F64x2ReplaceLane(lane),
-
-            De::I8x16Splat => En::I8x16Splat,
-            De::I16x8Splat => En::I16x8Splat,
-            De::I32x4Splat => En::I32x4Splat,
-            De::I64x2Splat => En::I64x2Splat,
-            De::F32x4Splat => En::F32x4Splat,
-            De::F64x2Splat => En::F64x2Splat,
-            De::I8x16Swizzle => En::I8x16Swizzle,
-            De::I8x16Add => En::I8x16Add,
-            De::I16x8Add => En::I16x8Add,
-            De::I32x4Add => En::I32x4Add,
-            De::I64x2Add => En::I64x2Add,
-            De::F32x4Add => En::F32x4Add,
-            De::F64x2Add => En::F64x2Add,
-            De::I8x16Sub => En::I8x16Sub,
-            De::I16x8Sub => En::I16x8Sub,
-            De::I32x4Sub => En::I32x4Sub,
-            De::I64x2Sub => En::I64x2Sub,
-            De::F32x4Sub => En::F32x4Sub,
-            De::F64x2Sub => En::F64x2Sub,
-            De::I16x8Mul => En::I16x8Mul,
-            De::I32x4Mul => En::I32x4Mul,
-            De::I64x2Mul => En::I64x2Mul,
-            De::F32x4Mul => En::F32x4Mul,
-            De::F64x2Mul => En::F64x2Mul,
-            De::I32x4DotI16x8S => En::I32x4DotI16x8S,
-            De::I8x16Neg => En::I8x16Neg,
-            De::I16x8Neg => En::I16x8Neg,
-            De::I32x4Neg => En::I32x4Neg,
-            De::I64x2Neg => En::I64x2Neg,
-            De::F32x4Neg => En::F32x4Neg,
-            De::F64x2Neg => En::F64x2Neg,
-            De::I16x8ExtMulLowI8x16S => En::I16x8ExtMulLowI8x16S,
-            De::I16x8ExtMulHighI8x16S => En::I16x8ExtMulHighI8x16S,
-            De::I16x8ExtMulLowI8x16U => En::I16x8ExtMulLowI8x16U,
-            De::I16x8ExtMulHighI8x16U => En::I16x8ExtMulHighI8x16U,
-            De::I32x4ExtMulLowI16x8S => En::I32x4ExtMulLowI16x8S,
-            De::I32x4ExtMulHighI16x8S => En::I32x4ExtMulHighI16x8S,
-            De::I32x4ExtMulLowI16x8U => En::I32x4ExtMulLowI16x8U,
-            De::I32x4ExtMulHighI16x8U => En::I32x4ExtMulHighI16x8U,
-            De::I64x2ExtMulLowI32x4S => En::I64x2ExtMulLowI32x4S,
-            De::I64x2ExtMulHighI32x4S => En::I64x2ExtMulHighI32x4S,
-            De::I64x2ExtMulLowI32x4U => En::I64x2ExtMulLowI32x4U,
-            De::I64x2ExtMulHighI32x4U => En::I64x2ExtMulHighI32x4U,
-            De::I16x8ExtAddPairwiseI8x16S => En::I16x8ExtAddPairwiseI8x16S,
-            De::I16x8ExtAddPairwiseI8x16U => En::I16x8ExtAddPairwiseI8x16U,
-            De::I32x4ExtAddPairwiseI16x8S => En::I32x4ExtAddPairwiseI16x8S,
-            De::I32x4ExtAddPairwiseI16x8U => En::I32x4ExtAddPairwiseI16x8U,
-            De::I8x16AddSatS => En::I8x16AddSatS,
-            De::I8x16AddSatU => En::I8x16AddSatU,
-            De::I16x8AddSatS => En::I16x8AddSatS,
-            De::I16x8AddSatU => En::I16x8AddSatU,
-            De::I8x16SubSatS => En::I8x16SubSatS,
-            De::I8x16SubSatU => En::I8x16SubSatU,
-            De::I16x8SubSatS => En::I16x8SubSatS,
-            De::I16x8SubSatU => En::I16x8SubSatU,
-            De::I16x8Q15MulrSatS => En::I16x8Q15MulrSatS,
-            De::I8x16MinS => En::I8x16MinS,
-            De::I8x16MinU => En::I8x16MinU,
-            De::I16x8MinS => En::I16x8MinS,
-            De::I16x8MinU => En::I16x8MinU,
-            De::I32x4MinS => En::I32x4MinS,
-            De::I32x4MinU => En::I32x4MinU,
-            De::F32x4Min => En::F32x4Min,
-            De::F64x2Min => En::F64x2Min,
-            De::F32x4PMin => En::F32x4PMin,
-            De::F64x2PMin => En::F64x2PMin,
-            De::I8x16MaxS => En::I8x16MaxS,
-            De::I8x16MaxU => En::I8x16MaxU,
-            De::I16x8MaxS => En::I16x8MaxS,
-            De::I16x8MaxU => En::I16x8MaxU,
-            De::I32x4MaxS => En::I32x4MaxS,
-            De::I32x4MaxU => En::I32x4MaxU,
-            De::F32x4Max => En::F32x4Max,
-            De::F64x2Max => En::F64x2Max,
-            De::F32x4PMax => En::F32x4PMax,
-            De::F64x2PMax => En::F64x2PMax,
-            De::I8x16AvgrU => En::I8x16AvgrU,
-            De::I16x8AvgrU => En::I16x8AvgrU,
-            De::I8x16Abs => En::I8x16Abs,
-            De::I16x8Abs => En::I16x8Abs,
-            De::I32x4Abs => En::I32x4Abs,
-            De::I64x2Abs => En::I64x2Abs,
-            De::F32x4Abs => En::F32x4Abs,
-            De::F64x2Abs => En::F64x2Abs,
-            De::I8x16Shl => En::I8x16Shl,
-            De::I16x8Shl => En::I16x8Shl,
-            De::I32x4Shl => En::I32x4Shl,
-            De::I64x2Shl => En::I64x2Shl,
-            De::I8x16ShrS => En::I8x16ShrS,
-            De::I8x16ShrU => En::I8x16ShrU,
-            De::I16x8ShrS => En::I16x8ShrS,
-            De::I16x8ShrU => En::I16x8ShrU,
-            De::I32x4ShrS => En::I32x4ShrS,
-            De::I32x4ShrU => En::I32x4ShrU,
-            De::I64x2ShrS => En::I64x2ShrS,
-            De::I64x2ShrU => En::I64x2ShrU,
-            De::V128And => En::V128And,
-            De::V128Or => En::V128Or,
-            De::V128Xor => En::V128Xor,
-            De::V128Not => En::V128Not,
-            De::V128AndNot => En::V128AndNot,
-            De::V128Bitselect => En::V128Bitselect,
-            De::I8x16Popcnt => En::I8x16Popcnt,
-            De::V128AnyTrue => En::V128AnyTrue,
-            De::I8x16AllTrue => En::I8x16AllTrue,
-            De::I16x8AllTrue => En::I16x8AllTrue,
-            De::I32x4AllTrue => En::I32x4AllTrue,
-            De::I64x2AllTrue => En::I64x2AllTrue,
-            De::I8x16Bitmask => En::I8x16Bitmask,
-            De::I16x8Bitmask => En::I16x8Bitmask,
-            De::I32x4Bitmask => En::I32x4Bitmask,
-            De::I64x2Bitmask => En::I64x2Bitmask,
-            De::I8x16Eq => En::I8x16Eq,
-            De::I16x8Eq => En::I16x8Eq,
-            De::I32x4Eq => En::I32x4Eq,
-            De::I64x2Eq => En::I64x2Eq,
-            De::F32x4Eq => En::F32x4Eq,
-            De::F64x2Eq => En::F64x2Eq,
-            De::I8x16Ne => En::I8x16Ne,
-            De::I16x8Ne => En::I16x8Ne,
-            De::I32x4Ne => En::I32x4Ne,
-            De::I64x2Ne => En::I64x2Ne,
-            De::F32x4Ne => En::F32x4Ne,
-            De::F64x2Ne => En::F64x2Ne,
-            De::I8x16LtS => En::I8x16LtS,
-            De::I8x16LtU => En::I8x16LtU,
-            De::I16x8LtS => En::I16x8LtS,
-            De::I16x8LtU => En::I16x8LtU,
-            De::I32x4LtS => En::I32x4LtS,
-            De::I32x4LtU => En::I32x4LtU,
-            De::F32x4Lt => En::F32x4Lt,
-            De::F64x2Lt => En::F64x2Lt,
-            De::I8x16LeS => En::I8x16LeS,
-            De::I8x16LeU => En::I8x16LeU,
-            De::I16x8LeS => En::I16x8LeS,
-            De::I16x8LeU => En::I16x8LeU,
-            De::I32x4LeS => En::I32x4LeS,
-            De::I32x4LeU => En::I32x4LeU,
-            De::F32x4Le => En::F32x4Le,
-            De::F64x2Le => En::F64x2Le,
-            De::I8x16GtS => En::I8x16GtS,
-            De::I8x16GtU => En::I8x16GtU,
-            De::I16x8GtS => En::I16x8GtS,
-            De::I16x8GtU => En::I16x8GtU,
-            De::I32x4GtS => En::I32x4GtS,
-            De::I32x4GtU => En::I32x4GtU,
-            De::F32x4Gt => En::F32x4Gt,
-            De::F64x2Gt => En::F64x2Gt,
-            De::I8x16GeS => En::I8x16GeS,
-            De::I8x16GeU => En::I8x16GeU,
-            De::I16x8GeS => En::I16x8GeS,
-            De::I16x8GeU => En::I16x8GeU,
-            De::I32x4GeS => En::I32x4GeS,
-            De::I32x4GeU => En::I32x4GeU,
-            De::F32x4Ge => En::F32x4Ge,
-            De::F64x2Ge => En::F64x2Ge,
-            De::F32x4Div => En::F32x4Div,
-            De::F64x2Div => En::F64x2Div,
-            De::F32x4Sqrt => En::F32x4Sqrt,
-            De::F64x2Sqrt => En::F64x2Sqrt,
-            De::F32x4Ceil => En::F32x4Ceil,
-            De::F64x2Ceil => En::F64x2Ceil,
-            De::F32x4Floor => En::F32x4Floor,
-            De::F64x2Floor => En::F64x2Floor,
-            De::F32x4Trunc => En::F32x4Trunc,
-            De::F64x2Trunc => En::F64x2Trunc,
-            De::F32x4Nearest => En::F32x4Nearest,
-            De::F64x2Nearest => En::F64x2Nearest,
-            De::F32x4ConvertI32x4S => En::F32x4ConvertI32x4S,
-            De::F32x4ConvertI32x4U => En::F32x4ConvertI32x4U,
-            De::F64x2ConvertLowI32x4S => En::F64x2ConvertLowI32x4S,
-            De::F64x2ConvertLowI32x4U => En::F64x2ConvertLowI32x4U,
-            De::I32x4TruncSatF32x4S => En::I32x4TruncSatF32x4S,
-            De::I32x4TruncSatF32x4U => En::I32x4TruncSatF32x4U,
-            De::I32x4TruncSatF64x2SZero => En::I32x4TruncSatF64x2SZero,
-            De::I32x4TruncSatF64x2UZero => En::I32x4TruncSatF64x2UZero,
-            De::F32x4DemoteF64x2Zero => En::F32x4DemoteF64x2Zero,
-            De::F64x2PromoteLowF32x4 => En::F64x2PromoteLowF32x4,
-            De::I8x16NarrowI16x8S => En::I8x16NarrowI16x8S,
-            De::I8x16NarrowI16x8U => En::I8x16NarrowI16x8U,
-            De::I16x8NarrowI32x4S => En::I16x8NarrowI32x4S,
-            De::I16x8NarrowI32x4U => En::I16x8NarrowI32x4U,
-            De::I16x8ExtendLowI8x16S => En::I16x8ExtendLowI8x16S,
-            De::I16x8ExtendHighI8x16S => En::I16x8ExtendHighI8x16S,
-            De::I16x8ExtendLowI8x16U => En::I16x8ExtendLowI8x16U,
-            De::I16x8ExtendHighI8x16U => En::I16x8ExtendHighI8x16U,
-            De::I32x4ExtendLowI16x8S => En::I32x4ExtendLowI16x8S,
-            De::I32x4ExtendHighI16x8S => En::I32x4ExtendHighI16x8S,
-            De::I32x4ExtendLowI16x8U => En::I32x4ExtendLowI16x8U,
-            De::I32x4ExtendHighI16x8U => En::I32x4ExtendHighI16x8U,
-            De::I64x2ExtendLowI32x4S => En::I64x2ExtendLowI32x4S,
-            De::I64x2ExtendHighI32x4S => En::I64x2ExtendHighI32x4S,
-            De::I64x2ExtendLowI32x4U => En::I64x2ExtendLowI32x4U,
-            De::I64x2ExtendHighI32x4U => En::I64x2ExtendHighI32x4U,
-
-            De::I8x16Shuffle { lanes } => En::I8x16Shuffle(lanes),
-
             other => bail!("Unsupported instruction {:?}", other),
         });
     }